/* ----------------------------------------------------------------------------
 * 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    "_soqt"
/* -----------------------------------------------------------------------------
 *  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_FatalErrorCB swig_types[3]
#define SWIGTYPE_p_Key swig_types[4]
#define SWIGTYPE_p_ProgressCallbackType swig_types[5]
#define SWIGTYPE_p_QEvent swig_types[6]
#define SWIGTYPE_p_QWidget swig_types[7]
#define SWIGTYPE_p_SbColor swig_types[8]
#define SWIGTYPE_p_SbColor4f swig_types[9]
#define SWIGTYPE_p_SbDPMatrix swig_types[10]
#define SWIGTYPE_p_SbDPRotation swig_types[11]
#define SWIGTYPE_p_SbDict swig_types[12]
#define SWIGTYPE_p_SbHeapFuncs swig_types[13]
#define SWIGTYPE_p_SbIntList swig_types[14]
#define SWIGTYPE_p_SbMatrix swig_types[15]
#define SWIGTYPE_p_SbName swig_types[16]
#define SWIGTYPE_p_SbOctTreeFuncs swig_types[17]
#define SWIGTYPE_p_SbPList swig_types[18]
#define SWIGTYPE_p_SbPlane swig_types[19]
#define SWIGTYPE_p_SbRotation swig_types[20]
#define SWIGTYPE_p_SbString swig_types[21]
#define SWIGTYPE_p_SbStringList swig_types[22]
#define SWIGTYPE_p_SbTime swig_types[23]
#define SWIGTYPE_p_SbVec2b swig_types[24]
#define SWIGTYPE_p_SbVec2d swig_types[25]
#define SWIGTYPE_p_SbVec2f swig_types[26]
#define SWIGTYPE_p_SbVec2i32 swig_types[27]
#define SWIGTYPE_p_SbVec2s swig_types[28]
#define SWIGTYPE_p_SbVec2us swig_types[29]
#define SWIGTYPE_p_SbVec3d swig_types[30]
#define SWIGTYPE_p_SbVec3f swig_types[31]
#define SWIGTYPE_p_SbVec3fList swig_types[32]
#define SWIGTYPE_p_SbVec4f swig_types[33]
#define SWIGTYPE_p_SbViewportRegion swig_types[34]
#define SWIGTYPE_p_SoActionMethodList swig_types[35]
#define SWIGTYPE_p_SoAlphaTest swig_types[36]
#define SWIGTYPE_p_SoAnnotation swig_types[37]
#define SWIGTYPE_p_SoAntiSquish swig_types[38]
#define SWIGTYPE_p_SoAppearanceKit swig_types[39]
#define SWIGTYPE_p_SoArray swig_types[40]
#define SWIGTYPE_p_SoAsciiText swig_types[41]
#define SWIGTYPE_p_SoAuditorList swig_types[42]
#define SWIGTYPE_p_SoBase swig_types[43]
#define SWIGTYPE_p_SoBaseColor swig_types[44]
#define SWIGTYPE_p_SoBaseKit swig_types[45]
#define SWIGTYPE_p_SoBaseList swig_types[46]
#define SWIGTYPE_p_SoBlinker swig_types[47]
#define SWIGTYPE_p_SoBoolOperation swig_types[48]
#define SWIGTYPE_p_SoBoxHighlightRenderAction swig_types[49]
#define SWIGTYPE_p_SoBumpMap swig_types[50]
#define SWIGTYPE_p_SoBumpMapCoordinate swig_types[51]
#define SWIGTYPE_p_SoBumpMapTransform swig_types[52]
#define SWIGTYPE_p_SoButtonEvent swig_types[53]
#define SWIGTYPE_p_SoCacheHint swig_types[54]
#define SWIGTYPE_p_SoCalculator swig_types[55]
#define SWIGTYPE_p_SoCallback swig_types[56]
#define SWIGTYPE_p_SoCallbackActionCB swig_types[57]
#define SWIGTYPE_p_SoCamera swig_types[58]
#define SWIGTYPE_p_SoCameraKit swig_types[59]
#define SWIGTYPE_p_SoCenterballDragger swig_types[60]
#define SWIGTYPE_p_SoCenterballManip swig_types[61]
#define SWIGTYPE_p_SoChildList swig_types[62]
#define SWIGTYPE_p_SoClipPlane swig_types[63]
#define SWIGTYPE_p_SoClipPlaneManip swig_types[64]
#define SWIGTYPE_p_SoColorIndex swig_types[65]
#define SWIGTYPE_p_SoComplexity swig_types[66]
#define SWIGTYPE_p_SoComposeMatrix swig_types[67]
#define SWIGTYPE_p_SoComposeRotation swig_types[68]
#define SWIGTYPE_p_SoComposeRotationFromTo swig_types[69]
#define SWIGTYPE_p_SoComposeVec2f swig_types[70]
#define SWIGTYPE_p_SoComposeVec3f swig_types[71]
#define SWIGTYPE_p_SoComposeVec4f swig_types[72]
#define SWIGTYPE_p_SoComputeBoundingBox swig_types[73]
#define SWIGTYPE_p_SoConcatenate swig_types[74]
#define SWIGTYPE_p_SoCone swig_types[75]
#define SWIGTYPE_p_SoCoordinate3 swig_types[76]
#define SWIGTYPE_p_SoCoordinate4 swig_types[77]
#define SWIGTYPE_p_SoCounter swig_types[78]
#define SWIGTYPE_p_SoCube swig_types[79]
#define SWIGTYPE_p_SoCylinder swig_types[80]
#define SWIGTYPE_p_SoDebugError swig_types[81]
#define SWIGTYPE_p_SoDecomposeMatrix swig_types[82]
#define SWIGTYPE_p_SoDecomposeRotation swig_types[83]
#define SWIGTYPE_p_SoDecomposeVec2f swig_types[84]
#define SWIGTYPE_p_SoDecomposeVec3f swig_types[85]
#define SWIGTYPE_p_SoDecomposeVec4f swig_types[86]
#define SWIGTYPE_p_SoDepthBuffer swig_types[87]
#define SWIGTYPE_p_SoDetailList swig_types[88]
#define SWIGTYPE_p_SoDirectionalLight swig_types[89]
#define SWIGTYPE_p_SoDirectionalLightDragger swig_types[90]
#define SWIGTYPE_p_SoDirectionalLightManip swig_types[91]
#define SWIGTYPE_p_SoDragPointDragger swig_types[92]
#define SWIGTYPE_p_SoDragger swig_types[93]
#define SWIGTYPE_p_SoDrawStyle swig_types[94]
#define SWIGTYPE_p_SoElapsedTime swig_types[95]
#define SWIGTYPE_p_SoEngine swig_types[96]
#define SWIGTYPE_p_SoEngineList swig_types[97]
#define SWIGTYPE_p_SoEngineOutput swig_types[98]
#define SWIGTYPE_p_SoEngineOutputList swig_types[99]
#define SWIGTYPE_p_SoEnvironment swig_types[100]
#define SWIGTYPE_p_SoError swig_types[101]
#define SWIGTYPE_p_SoEvent swig_types[102]
#define SWIGTYPE_p_SoEventCallback swig_types[103]
#define SWIGTYPE_p_SoExtSelection swig_types[104]
#define SWIGTYPE_p_SoFaceSet swig_types[105]
#define SWIGTYPE_p_SoField swig_types[106]
#define SWIGTYPE_p_SoFieldContainer swig_types[107]
#define SWIGTYPE_p_SoFieldConverter swig_types[108]
#define SWIGTYPE_p_SoFieldList swig_types[109]
#define SWIGTYPE_p_SoFile swig_types[110]
#define SWIGTYPE_p_SoFont swig_types[111]
#define SWIGTYPE_p_SoFontStyle swig_types[112]
#define SWIGTYPE_p_SoFragmentShader swig_types[113]
#define SWIGTYPE_p_SoFrustumCamera swig_types[114]
#define SWIGTYPE_p_SoFullPath swig_types[115]
#define SWIGTYPE_p_SoGLImageResizeCB swig_types[116]
#define SWIGTYPE_p_SoGLMultiTextureCoordinateElement swig_types[117]
#define SWIGTYPE_p_SoGLMultiTextureEnabledElement swig_types[118]
#define SWIGTYPE_p_SoGLMultiTextureImageElement swig_types[119]
#define SWIGTYPE_p_SoGLMultiTextureMatrixElement swig_types[120]
#define SWIGTYPE_p_SoGLRenderAbortCB swig_types[121]
#define SWIGTYPE_p_SoGLRenderAction swig_types[122]
#define SWIGTYPE_p_SoGate swig_types[123]
#define SWIGTYPE_p_SoGeoCoordinate swig_types[124]
#define SWIGTYPE_p_SoGeoLocation swig_types[125]
#define SWIGTYPE_p_SoGeoOrigin swig_types[126]
#define SWIGTYPE_p_SoGeoSeparator swig_types[127]
#define SWIGTYPE_p_SoGroup swig_types[128]
#define SWIGTYPE_p_SoHandleBoxDragger swig_types[129]
#define SWIGTYPE_p_SoHandleBoxManip swig_types[130]
#define SWIGTYPE_p_SoHeightMapToNormalMap swig_types[131]
#define SWIGTYPE_p_SoImage swig_types[132]
#define SWIGTYPE_p_SoIndexedFaceSet swig_types[133]
#define SWIGTYPE_p_SoIndexedLineSet swig_types[134]
#define SWIGTYPE_p_SoIndexedMarkerSet swig_types[135]
#define SWIGTYPE_p_SoIndexedNurbsCurve swig_types[136]
#define SWIGTYPE_p_SoIndexedNurbsSurface swig_types[137]
#define SWIGTYPE_p_SoIndexedPointSet swig_types[138]
#define SWIGTYPE_p_SoIndexedShape swig_types[139]
#define SWIGTYPE_p_SoIndexedTriangleStripSet swig_types[140]
#define SWIGTYPE_p_SoInfo swig_types[141]
#define SWIGTYPE_p_SoInput swig_types[142]
#define SWIGTYPE_p_SoInteractionKit swig_types[143]
#define SWIGTYPE_p_SoInterpolate swig_types[144]
#define SWIGTYPE_p_SoInterpolateFloat swig_types[145]
#define SWIGTYPE_p_SoInterpolateRotation swig_types[146]
#define SWIGTYPE_p_SoInterpolateVec2f swig_types[147]
#define SWIGTYPE_p_SoInterpolateVec3f swig_types[148]
#define SWIGTYPE_p_SoInterpolateVec4f swig_types[149]
#define SWIGTYPE_p_SoIntersectionCB swig_types[150]
#define SWIGTYPE_p_SoIntersectionFilterCB swig_types[151]
#define SWIGTYPE_p_SoIntersectionVisitationCB swig_types[152]
#define SWIGTYPE_p_SoJackDragger swig_types[153]
#define SWIGTYPE_p_SoJackManip swig_types[154]
#define SWIGTYPE_p_SoKeyboardEvent swig_types[155]
#define SWIGTYPE_p_SoLOD swig_types[156]
#define SWIGTYPE_p_SoLabel swig_types[157]
#define SWIGTYPE_p_SoLevelOfDetail swig_types[158]
#define SWIGTYPE_p_SoLight swig_types[159]
#define SWIGTYPE_p_SoLightKit swig_types[160]
#define SWIGTYPE_p_SoLightModel swig_types[161]
#define SWIGTYPE_p_SoLineHighlightRenderAction swig_types[162]
#define SWIGTYPE_p_SoLineSet swig_types[163]
#define SWIGTYPE_p_SoLinearProfile swig_types[164]
#define SWIGTYPE_p_SoListener swig_types[165]
#define SWIGTYPE_p_SoLocateHighlight swig_types[166]
#define SWIGTYPE_p_SoLocation2Event swig_types[167]
#define SWIGTYPE_p_SoMFBitMask swig_types[168]
#define SWIGTYPE_p_SoMFBool swig_types[169]
#define SWIGTYPE_p_SoMFColor swig_types[170]
#define SWIGTYPE_p_SoMFColorRGBA swig_types[171]
#define SWIGTYPE_p_SoMFDouble swig_types[172]
#define SWIGTYPE_p_SoMFEngine swig_types[173]
#define SWIGTYPE_p_SoMFEnum swig_types[174]
#define SWIGTYPE_p_SoMFFloat swig_types[175]
#define SWIGTYPE_p_SoMFInt32 swig_types[176]
#define SWIGTYPE_p_SoMFMatrix swig_types[177]
#define SWIGTYPE_p_SoMFName swig_types[178]
#define SWIGTYPE_p_SoMFNode swig_types[179]
#define SWIGTYPE_p_SoMFPath swig_types[180]
#define SWIGTYPE_p_SoMFPlane swig_types[181]
#define SWIGTYPE_p_SoMFRotation swig_types[182]
#define SWIGTYPE_p_SoMFShort swig_types[183]
#define SWIGTYPE_p_SoMFString swig_types[184]
#define SWIGTYPE_p_SoMFTime swig_types[185]
#define SWIGTYPE_p_SoMFUInt32 swig_types[186]
#define SWIGTYPE_p_SoMFUShort swig_types[187]
#define SWIGTYPE_p_SoMFVec2b swig_types[188]
#define SWIGTYPE_p_SoMFVec2d swig_types[189]
#define SWIGTYPE_p_SoMFVec2f swig_types[190]
#define SWIGTYPE_p_SoMFVec2i32 swig_types[191]
#define SWIGTYPE_p_SoMFVec2s swig_types[192]
#define SWIGTYPE_p_SoMFVec3b swig_types[193]
#define SWIGTYPE_p_SoMFVec3d swig_types[194]
#define SWIGTYPE_p_SoMFVec3f swig_types[195]
#define SWIGTYPE_p_SoMFVec3i32 swig_types[196]
#define SWIGTYPE_p_SoMFVec3s swig_types[197]
#define SWIGTYPE_p_SoMFVec4b swig_types[198]
#define SWIGTYPE_p_SoMFVec4d swig_types[199]
#define SWIGTYPE_p_SoMFVec4f swig_types[200]
#define SWIGTYPE_p_SoMFVec4i32 swig_types[201]
#define SWIGTYPE_p_SoMFVec4s swig_types[202]
#define SWIGTYPE_p_SoMFVec4ub swig_types[203]
#define SWIGTYPE_p_SoMFVec4ui32 swig_types[204]
#define SWIGTYPE_p_SoMFVec4us swig_types[205]
#define SWIGTYPE_p_SoMField swig_types[206]
#define SWIGTYPE_p_SoMarkerSet swig_types[207]
#define SWIGTYPE_p_SoMaterial swig_types[208]
#define SWIGTYPE_p_SoMaterialBinding swig_types[209]
#define SWIGTYPE_p_SoMatrixTransform swig_types[210]
#define SWIGTYPE_p_SoMemoryError swig_types[211]
#define SWIGTYPE_p_SoMotion3Event swig_types[212]
#define SWIGTYPE_p_SoMouseButtonEvent swig_types[213]
#define SWIGTYPE_p_SoMultiTextureCoordinateElement swig_types[214]
#define SWIGTYPE_p_SoMultiTextureEnabledElement swig_types[215]
#define SWIGTYPE_p_SoMultiTextureImageElement swig_types[216]
#define SWIGTYPE_p_SoMultiTextureMatrixElement swig_types[217]
#define SWIGTYPE_p_SoMultipleCopy swig_types[218]
#define SWIGTYPE_p_SoNode swig_types[219]
#define SWIGTYPE_p_SoNodeEngine swig_types[220]
#define SWIGTYPE_p_SoNodeKitListPart swig_types[221]
#define SWIGTYPE_p_SoNodeKitPath swig_types[222]
#define SWIGTYPE_p_SoNodeList swig_types[223]
#define SWIGTYPE_p_SoNonIndexedShape swig_types[224]
#define SWIGTYPE_p_SoNormal swig_types[225]
#define SWIGTYPE_p_SoNormalBinding swig_types[226]
#define SWIGTYPE_p_SoNotList swig_types[227]
#define SWIGTYPE_p_SoNotRec swig_types[228]
#define SWIGTYPE_p_SoNurbsCurve swig_types[229]
#define SWIGTYPE_p_SoNurbsProfile swig_types[230]
#define SWIGTYPE_p_SoNurbsSurface swig_types[231]
#define SWIGTYPE_p_SoOnOff swig_types[232]
#define SWIGTYPE_p_SoOneShot swig_types[233]
#define SWIGTYPE_p_SoOrthographicCamera swig_types[234]
#define SWIGTYPE_p_SoOutput swig_types[235]
#define SWIGTYPE_p_SoPackedColor swig_types[236]
#define SWIGTYPE_p_SoPath swig_types[237]
#define SWIGTYPE_p_SoPathList swig_types[238]
#define SWIGTYPE_p_SoPathSwitch swig_types[239]
#define SWIGTYPE_p_SoPendulum swig_types[240]
#define SWIGTYPE_p_SoPerspectiveCamera swig_types[241]
#define SWIGTYPE_p_SoPickStyle swig_types[242]
#define SWIGTYPE_p_SoPickedPointList swig_types[243]
#define SWIGTYPE_p_SoPointLight swig_types[244]
#define SWIGTYPE_p_SoPointLightDragger swig_types[245]
#define SWIGTYPE_p_SoPointLightManip swig_types[246]
#define SWIGTYPE_p_SoPointSet swig_types[247]
#define SWIGTYPE_p_SoPolygonOffset swig_types[248]
#define SWIGTYPE_p_SoProfile swig_types[249]
#define SWIGTYPE_p_SoProfileCoordinate2 swig_types[250]
#define SWIGTYPE_p_SoProfileCoordinate3 swig_types[251]
#define SWIGTYPE_p_SoProto swig_types[252]
#define SWIGTYPE_p_SoProtoInstance swig_types[253]
#define SWIGTYPE_p_SoQt swig_types[254]
#define SWIGTYPE_p_SoQtComponent swig_types[255]
#define SWIGTYPE_p_SoQtConstrainedViewer swig_types[256]
#define SWIGTYPE_p_SoQtCursor swig_types[257]
#define SWIGTYPE_p_SoQtCursor__CustomCursor swig_types[258]
#define SWIGTYPE_p_SoQtDevice swig_types[259]
#define SWIGTYPE_p_SoQtExaminerViewer swig_types[260]
#define SWIGTYPE_p_SoQtFlyViewer swig_types[261]
#define SWIGTYPE_p_SoQtFullViewer swig_types[262]
#define SWIGTYPE_p_SoQtGLWidget swig_types[263]
#define SWIGTYPE_p_SoQtKeyboard swig_types[264]
#define SWIGTYPE_p_SoQtMouse swig_types[265]
#define SWIGTYPE_p_SoQtObject swig_types[266]
#define SWIGTYPE_p_SoQtPlaneViewer swig_types[267]
#define SWIGTYPE_p_SoQtPopupMenu swig_types[268]
#define SWIGTYPE_p_SoQtRenderArea swig_types[269]
#define SWIGTYPE_p_SoQtViewer swig_types[270]
#define SWIGTYPE_p_SoQuadMesh swig_types[271]
#define SWIGTYPE_p_SoReadError swig_types[272]
#define SWIGTYPE_p_SoResetTransform swig_types[273]
#define SWIGTYPE_p_SoReversePerspectiveCamera swig_types[274]
#define SWIGTYPE_p_SoRotateCylindricalDragger swig_types[275]
#define SWIGTYPE_p_SoRotateDiscDragger swig_types[276]
#define SWIGTYPE_p_SoRotateSphericalDragger swig_types[277]
#define SWIGTYPE_p_SoRotation swig_types[278]
#define SWIGTYPE_p_SoRotationXYZ swig_types[279]
#define SWIGTYPE_p_SoRotor swig_types[280]
#define SWIGTYPE_p_SoSFBitMask swig_types[281]
#define SWIGTYPE_p_SoSFBool swig_types[282]
#define SWIGTYPE_p_SoSFBox2d swig_types[283]
#define SWIGTYPE_p_SoSFBox2f swig_types[284]
#define SWIGTYPE_p_SoSFBox2i32 swig_types[285]
#define SWIGTYPE_p_SoSFBox2s swig_types[286]
#define SWIGTYPE_p_SoSFBox3d swig_types[287]
#define SWIGTYPE_p_SoSFBox3f swig_types[288]
#define SWIGTYPE_p_SoSFBox3i32 swig_types[289]
#define SWIGTYPE_p_SoSFBox3s swig_types[290]
#define SWIGTYPE_p_SoSFColor swig_types[291]
#define SWIGTYPE_p_SoSFColorRGBA swig_types[292]
#define SWIGTYPE_p_SoSFDouble swig_types[293]
#define SWIGTYPE_p_SoSFEngine swig_types[294]
#define SWIGTYPE_p_SoSFEnum swig_types[295]
#define SWIGTYPE_p_SoSFFloat swig_types[296]
#define SWIGTYPE_p_SoSFImage swig_types[297]
#define SWIGTYPE_p_SoSFImage3 swig_types[298]
#define SWIGTYPE_p_SoSFInt32 swig_types[299]
#define SWIGTYPE_p_SoSFMatrix swig_types[300]
#define SWIGTYPE_p_SoSFName swig_types[301]
#define SWIGTYPE_p_SoSFNode swig_types[302]
#define SWIGTYPE_p_SoSFPath swig_types[303]
#define SWIGTYPE_p_SoSFPlane swig_types[304]
#define SWIGTYPE_p_SoSFRotation swig_types[305]
#define SWIGTYPE_p_SoSFShort swig_types[306]
#define SWIGTYPE_p_SoSFString swig_types[307]
#define SWIGTYPE_p_SoSFTime swig_types[308]
#define SWIGTYPE_p_SoSFTrigger swig_types[309]
#define SWIGTYPE_p_SoSFUInt32 swig_types[310]
#define SWIGTYPE_p_SoSFUShort swig_types[311]
#define SWIGTYPE_p_SoSFVec2b swig_types[312]
#define SWIGTYPE_p_SoSFVec2d swig_types[313]
#define SWIGTYPE_p_SoSFVec2f swig_types[314]
#define SWIGTYPE_p_SoSFVec2i32 swig_types[315]
#define SWIGTYPE_p_SoSFVec2s swig_types[316]
#define SWIGTYPE_p_SoSFVec3b swig_types[317]
#define SWIGTYPE_p_SoSFVec3d swig_types[318]
#define SWIGTYPE_p_SoSFVec3f swig_types[319]
#define SWIGTYPE_p_SoSFVec3i32 swig_types[320]
#define SWIGTYPE_p_SoSFVec3s swig_types[321]
#define SWIGTYPE_p_SoSFVec4b swig_types[322]
#define SWIGTYPE_p_SoSFVec4d swig_types[323]
#define SWIGTYPE_p_SoSFVec4f swig_types[324]
#define SWIGTYPE_p_SoSFVec4i32 swig_types[325]
#define SWIGTYPE_p_SoSFVec4s swig_types[326]
#define SWIGTYPE_p_SoSFVec4ub swig_types[327]
#define SWIGTYPE_p_SoSFVec4ui32 swig_types[328]
#define SWIGTYPE_p_SoSFVec4us swig_types[329]
#define SWIGTYPE_p_SoSField swig_types[330]
#define SWIGTYPE_p_SoScale swig_types[331]
#define SWIGTYPE_p_SoScale1Dragger swig_types[332]
#define SWIGTYPE_p_SoScale2Dragger swig_types[333]
#define SWIGTYPE_p_SoScale2UniformDragger swig_types[334]
#define SWIGTYPE_p_SoScaleUniformDragger swig_types[335]
#define SWIGTYPE_p_SoSceneKit swig_types[336]
#define SWIGTYPE_p_SoSceneManager swig_types[337]
#define SWIGTYPE_p_SoSceneTexture2 swig_types[338]
#define SWIGTYPE_p_SoSceneTextureCubeMap swig_types[339]
#define SWIGTYPE_p_SoSelectOne swig_types[340]
#define SWIGTYPE_p_SoSelection swig_types[341]
#define SWIGTYPE_p_SoSeparator swig_types[342]
#define SWIGTYPE_p_SoSeparatorKit swig_types[343]
#define SWIGTYPE_p_SoShaderObject swig_types[344]
#define SWIGTYPE_p_SoShaderParameter swig_types[345]
#define SWIGTYPE_p_SoShaderParameter1f swig_types[346]
#define SWIGTYPE_p_SoShaderParameter1i swig_types[347]
#define SWIGTYPE_p_SoShaderParameter2f swig_types[348]
#define SWIGTYPE_p_SoShaderParameter2i swig_types[349]
#define SWIGTYPE_p_SoShaderParameter3f swig_types[350]
#define SWIGTYPE_p_SoShaderParameter3i swig_types[351]
#define SWIGTYPE_p_SoShaderParameter4f swig_types[352]
#define SWIGTYPE_p_SoShaderParameter4i swig_types[353]
#define SWIGTYPE_p_SoShaderParameterArray1f swig_types[354]
#define SWIGTYPE_p_SoShaderParameterArray1i swig_types[355]
#define SWIGTYPE_p_SoShaderParameterArray2f swig_types[356]
#define SWIGTYPE_p_SoShaderParameterArray2i swig_types[357]
#define SWIGTYPE_p_SoShaderParameterArray3f swig_types[358]
#define SWIGTYPE_p_SoShaderParameterArray3i swig_types[359]
#define SWIGTYPE_p_SoShaderParameterArray4f swig_types[360]
#define SWIGTYPE_p_SoShaderParameterArray4i swig_types[361]
#define SWIGTYPE_p_SoShaderParameterMatrix swig_types[362]
#define SWIGTYPE_p_SoShaderParameterMatrixArray swig_types[363]
#define SWIGTYPE_p_SoShaderProgram swig_types[364]
#define SWIGTYPE_p_SoShaderStateMatrixParameter swig_types[365]
#define SWIGTYPE_p_SoShape swig_types[366]
#define SWIGTYPE_p_SoShapeHints swig_types[367]
#define SWIGTYPE_p_SoShapeKit swig_types[368]
#define SWIGTYPE_p_SoShuttle swig_types[369]
#define SWIGTYPE_p_SoSpaceballButtonEvent swig_types[370]
#define SWIGTYPE_p_SoSphere swig_types[371]
#define SWIGTYPE_p_SoSpotLight swig_types[372]
#define SWIGTYPE_p_SoSpotLightDragger swig_types[373]
#define SWIGTYPE_p_SoSpotLightManip swig_types[374]
#define SWIGTYPE_p_SoSurroundScale swig_types[375]
#define SWIGTYPE_p_SoSwitch swig_types[376]
#define SWIGTYPE_p_SoTabBoxDragger swig_types[377]
#define SWIGTYPE_p_SoTabBoxManip swig_types[378]
#define SWIGTYPE_p_SoTabPlaneDragger swig_types[379]
#define SWIGTYPE_p_SoTempPath swig_types[380]
#define SWIGTYPE_p_SoText2 swig_types[381]
#define SWIGTYPE_p_SoText3 swig_types[382]
#define SWIGTYPE_p_SoTexture swig_types[383]
#define SWIGTYPE_p_SoTexture2 swig_types[384]
#define SWIGTYPE_p_SoTexture2Convert swig_types[385]
#define SWIGTYPE_p_SoTexture2Transform swig_types[386]
#define SWIGTYPE_p_SoTexture3 swig_types[387]
#define SWIGTYPE_p_SoTexture3Transform swig_types[388]
#define SWIGTYPE_p_SoTextureCombine swig_types[389]
#define SWIGTYPE_p_SoTextureCoordinate2 swig_types[390]
#define SWIGTYPE_p_SoTextureCoordinate3 swig_types[391]
#define SWIGTYPE_p_SoTextureCoordinateBinding swig_types[392]
#define SWIGTYPE_p_SoTextureCoordinateCube swig_types[393]
#define SWIGTYPE_p_SoTextureCoordinateCylinder swig_types[394]
#define SWIGTYPE_p_SoTextureCoordinateDefault swig_types[395]
#define SWIGTYPE_p_SoTextureCoordinateEnvironment swig_types[396]
#define SWIGTYPE_p_SoTextureCoordinateFunction swig_types[397]
#define SWIGTYPE_p_SoTextureCoordinateNormalMap swig_types[398]
#define SWIGTYPE_p_SoTextureCoordinateObject swig_types[399]
#define SWIGTYPE_p_SoTextureCoordinatePlane swig_types[400]
#define SWIGTYPE_p_SoTextureCoordinateReflectionMap swig_types[401]
#define SWIGTYPE_p_SoTextureCoordinateSphere swig_types[402]
#define SWIGTYPE_p_SoTextureCubeMap swig_types[403]
#define SWIGTYPE_p_SoTextureMatrixTransform swig_types[404]
#define SWIGTYPE_p_SoTextureScalePolicy swig_types[405]
#define SWIGTYPE_p_SoTextureUnit swig_types[406]
#define SWIGTYPE_p_SoTimeCounter swig_types[407]
#define SWIGTYPE_p_SoTrackballDragger swig_types[408]
#define SWIGTYPE_p_SoTrackballManip swig_types[409]
#define SWIGTYPE_p_SoTransform swig_types[410]
#define SWIGTYPE_p_SoTransformBoxDragger swig_types[411]
#define SWIGTYPE_p_SoTransformBoxManip swig_types[412]
#define SWIGTYPE_p_SoTransformManip swig_types[413]
#define SWIGTYPE_p_SoTransformSeparator swig_types[414]
#define SWIGTYPE_p_SoTransformVec3f swig_types[415]
#define SWIGTYPE_p_SoTransformation swig_types[416]
#define SWIGTYPE_p_SoTransformerDragger swig_types[417]
#define SWIGTYPE_p_SoTransformerManip swig_types[418]
#define SWIGTYPE_p_SoTranslate1Dragger swig_types[419]
#define SWIGTYPE_p_SoTranslate2Dragger swig_types[420]
#define SWIGTYPE_p_SoTranslation swig_types[421]
#define SWIGTYPE_p_SoTransparencyType swig_types[422]
#define SWIGTYPE_p_SoTriangleStripSet swig_types[423]
#define SWIGTYPE_p_SoTriggerAny swig_types[424]
#define SWIGTYPE_p_SoType swig_types[425]
#define SWIGTYPE_p_SoTypeList swig_types[426]
#define SWIGTYPE_p_SoUniformShaderParameter swig_types[427]
#define SWIGTYPE_p_SoUnits swig_types[428]
#define SWIGTYPE_p_SoVRMLAnchor swig_types[429]
#define SWIGTYPE_p_SoVRMLAppearance swig_types[430]
#define SWIGTYPE_p_SoVRMLAudioClip swig_types[431]
#define SWIGTYPE_p_SoVRMLBackground swig_types[432]
#define SWIGTYPE_p_SoVRMLBillboard swig_types[433]
#define SWIGTYPE_p_SoVRMLBox swig_types[434]
#define SWIGTYPE_p_SoVRMLCollision swig_types[435]
#define SWIGTYPE_p_SoVRMLColor swig_types[436]
#define SWIGTYPE_p_SoVRMLColorInterpolator swig_types[437]
#define SWIGTYPE_p_SoVRMLCone swig_types[438]
#define SWIGTYPE_p_SoVRMLCoordinate swig_types[439]
#define SWIGTYPE_p_SoVRMLCoordinateInterpolator swig_types[440]
#define SWIGTYPE_p_SoVRMLCylinder swig_types[441]
#define SWIGTYPE_p_SoVRMLCylinderSensor swig_types[442]
#define SWIGTYPE_p_SoVRMLDirectionalLight swig_types[443]
#define SWIGTYPE_p_SoVRMLDragSensor swig_types[444]
#define SWIGTYPE_p_SoVRMLElevationGrid swig_types[445]
#define SWIGTYPE_p_SoVRMLExtrusion swig_types[446]
#define SWIGTYPE_p_SoVRMLFog swig_types[447]
#define SWIGTYPE_p_SoVRMLFontStyle swig_types[448]
#define SWIGTYPE_p_SoVRMLGeometry swig_types[449]
#define SWIGTYPE_p_SoVRMLGroup swig_types[450]
#define SWIGTYPE_p_SoVRMLImageTexture swig_types[451]
#define SWIGTYPE_p_SoVRMLIndexedFaceSet swig_types[452]
#define SWIGTYPE_p_SoVRMLIndexedLine swig_types[453]
#define SWIGTYPE_p_SoVRMLIndexedLineSet swig_types[454]
#define SWIGTYPE_p_SoVRMLIndexedShape swig_types[455]
#define SWIGTYPE_p_SoVRMLInline swig_types[456]
#define SWIGTYPE_p_SoVRMLInterpolator swig_types[457]
#define SWIGTYPE_p_SoVRMLLOD swig_types[458]
#define SWIGTYPE_p_SoVRMLLight swig_types[459]
#define SWIGTYPE_p_SoVRMLMaterial swig_types[460]
#define SWIGTYPE_p_SoVRMLMovieTexture swig_types[461]
#define SWIGTYPE_p_SoVRMLNavigationInfo swig_types[462]
#define SWIGTYPE_p_SoVRMLNormal swig_types[463]
#define SWIGTYPE_p_SoVRMLNormalInterpolator swig_types[464]
#define SWIGTYPE_p_SoVRMLOrientationInterpolator swig_types[465]
#define SWIGTYPE_p_SoVRMLParent swig_types[466]
#define SWIGTYPE_p_SoVRMLPixelTexture swig_types[467]
#define SWIGTYPE_p_SoVRMLPlaneSensor swig_types[468]
#define SWIGTYPE_p_SoVRMLPointLight swig_types[469]
#define SWIGTYPE_p_SoVRMLPointSet swig_types[470]
#define SWIGTYPE_p_SoVRMLPositionInterpolator swig_types[471]
#define SWIGTYPE_p_SoVRMLProximitySensor swig_types[472]
#define SWIGTYPE_p_SoVRMLScalarInterpolator swig_types[473]
#define SWIGTYPE_p_SoVRMLScript swig_types[474]
#define SWIGTYPE_p_SoVRMLSensor swig_types[475]
#define SWIGTYPE_p_SoVRMLShape swig_types[476]
#define SWIGTYPE_p_SoVRMLSound swig_types[477]
#define SWIGTYPE_p_SoVRMLSphere swig_types[478]
#define SWIGTYPE_p_SoVRMLSphereSensor swig_types[479]
#define SWIGTYPE_p_SoVRMLSpotLight swig_types[480]
#define SWIGTYPE_p_SoVRMLSwitch swig_types[481]
#define SWIGTYPE_p_SoVRMLText swig_types[482]
#define SWIGTYPE_p_SoVRMLTexture swig_types[483]
#define SWIGTYPE_p_SoVRMLTextureCoordinate swig_types[484]
#define SWIGTYPE_p_SoVRMLTextureTransform swig_types[485]
#define SWIGTYPE_p_SoVRMLTimeSensor swig_types[486]
#define SWIGTYPE_p_SoVRMLTouchSensor swig_types[487]
#define SWIGTYPE_p_SoVRMLTransform swig_types[488]
#define SWIGTYPE_p_SoVRMLVertexLine swig_types[489]
#define SWIGTYPE_p_SoVRMLVertexPoint swig_types[490]
#define SWIGTYPE_p_SoVRMLVertexShape swig_types[491]
#define SWIGTYPE_p_SoVRMLViewpoint swig_types[492]
#define SWIGTYPE_p_SoVRMLVisibilitySensor swig_types[493]
#define SWIGTYPE_p_SoVRMLWorldInfo swig_types[494]
#define SWIGTYPE_p_SoVertexAttribute swig_types[495]
#define SWIGTYPE_p_SoVertexAttributeBinding swig_types[496]
#define SWIGTYPE_p_SoVertexProperty swig_types[497]
#define SWIGTYPE_p_SoVertexShader swig_types[498]
#define SWIGTYPE_p_SoVertexShape swig_types[499]
#define SWIGTYPE_p_SoWWWAnchor swig_types[500]
#define SWIGTYPE_p_SoWWWInline swig_types[501]
#define SWIGTYPE_p_SoWrapperKit swig_types[502]
#define SWIGTYPE_p_a_4__a_4__double swig_types[503]
#define SWIGTYPE_p_a_4__a_4__doublep swig_types[504]
#define SWIGTYPE_p_a_4__a_4__float swig_types[505]
#define SWIGTYPE_p_a_4__a_4__floatp swig_types[506]
#define SWIGTYPE_p_cc_glglue swig_types[507]
#define SWIGTYPE_p_char swig_types[508]
#define SWIGTYPE_p_charp swig_types[509]
#define SWIGTYPE_p_close_func swig_types[510]
#define SWIGTYPE_p_double swig_types[511]
#define SWIGTYPE_p_doublep swig_types[512]
#define SWIGTYPE_p_f_char__char swig_types[513]
#define SWIGTYPE_p_f_char__charp swig_types[514]
#define SWIGTYPE_p_f_float_p_void_p_SoQtViewer__void swig_types[515]
#define SWIGTYPE_p_f_int_p_void__void swig_types[516]
#define SWIGTYPE_p_f_p_QWidget_p_void_p_QEvent_p_bool__void swig_types[517]
#define SWIGTYPE_p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto swig_types[518]
#define SWIGTYPE_p_f_p_q_const__SoError_p_void__void swig_types[519]
#define SWIGTYPE_p_f_p_void__void swig_types[520]
#define SWIGTYPE_p_f_p_void_int__void swig_types[521]
#define SWIGTYPE_p_f_p_void_p_QEvent__int swig_types[522]
#define SWIGTYPE_p_f_p_void_p_QEvent__intp swig_types[523]
#define SWIGTYPE_p_f_p_void_p_ScXMLStateMachine__void swig_types[524]
#define SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_int_p_p_q_const__char_int_int__void swig_types[525]
#define SWIGTYPE_p_f_p_void_p_ScXMLStateMachine_p_q_const__char_int_int__void swig_types[526]
#define SWIGTYPE_p_f_p_void_p_SoAction__void swig_types[527]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__int swig_types[528]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__intp swig_types[529]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex__void swig_types[530]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int swig_types[531]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp swig_types[532]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void swig_types[533]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__int swig_types[534]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__intp swig_types[535]
#define SWIGTYPE_p_f_p_void_p_SoCallbackAction_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex_p_q_const__SoPrimitiveVertex__void swig_types[536]
#define SWIGTYPE_p_f_p_void_p_SoDragger__void swig_types[537]
#define SWIGTYPE_p_f_p_void_p_SoEventCallback__void swig_types[538]
#define SWIGTYPE_p_f_p_void_p_SoGLRenderAction__float swig_types[539]
#define SWIGTYPE_p_f_p_void_p_SoGLRenderAction__floatp swig_types[540]
#define SWIGTYPE_p_f_p_void_p_SoGLRenderAction__void swig_types[541]
#define SWIGTYPE_p_f_p_void_p_SoInput__void swig_types[542]
#define SWIGTYPE_p_f_p_void_p_SoPath__void swig_types[543]
#define SWIGTYPE_p_f_p_void_p_SoQtComponent__void swig_types[544]
#define SWIGTYPE_p_f_p_void_p_SoQtViewer__void swig_types[545]
#define SWIGTYPE_p_f_p_void_p_SoRenderManager__void swig_types[546]
#define SWIGTYPE_p_f_p_void_p_SoSceneManager__void swig_types[547]
#define SWIGTYPE_p_f_p_void_p_SoSelection__void swig_types[548]
#define SWIGTYPE_p_f_p_void_p_SoSensor__void swig_types[549]
#define SWIGTYPE_p_f_p_void_p_SoState_q_const__int__void swig_types[550]
#define SWIGTYPE_p_f_p_void_p_SoVRMLScript__void swig_types[551]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoFullPath swig_types[552]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoNodeKitPath swig_types[553]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoPath swig_types[554]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPath__p_SoTempPath swig_types[555]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoFullPath swig_types[556]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoNodeKitPath swig_types[557]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoPath swig_types[558]
#define SWIGTYPE_p_f_p_void_p_q_const__SoPickedPoint__p_SoTempPath swig_types[559]
#define SWIGTYPE_p_f_p_void_p_void__void swig_types[560]
#define SWIGTYPE_p_f_p_void_p_void_p_void_p_void__void swig_types[561]
#define SWIGTYPE_p_f_p_void_r_q_const__SbVec2f__SbVec2f swig_types[562]
#define SWIGTYPE_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbColor4f swig_types[563]
#define SWIGTYPE_p_f_p_void_r_q_const__SbVec3f_r_q_const__SbVec3f__r_SbVec4f swig_types[564]
#define SWIGTYPE_p_f_p_void_size_t__p_void swig_types[565]
#define SWIGTYPE_p_f_p_void_unsigned_int__void swig_types[566]
#define SWIGTYPE_p_f_q_const__SbString_enum_SoQt__FatalErrors_p_void__void swig_types[567]
#define SWIGTYPE_p_f_q_const__unsigned_int__unsigned_int swig_types[568]
#define SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__int swig_types[569]
#define SWIGTYPE_p_f_r_q_const__SbString_p_SbImage_p_void__intp swig_types[570]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLAnchor__void swig_types[571]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__int swig_types[572]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLImageTexture__intp swig_types[573]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoVRMLInline__void swig_types[574]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoWWWAnchor__void swig_types[575]
#define SWIGTYPE_p_f_r_q_const__SbString_p_void_p_SoWWWInline__void swig_types[576]
#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[577]
#define SWIGTYPE_p_f_unsigned_int_p_void__void swig_types[578]
#define SWIGTYPE_p_f_unsigned_int_p_void_p_void__void swig_types[579]
#define SWIGTYPE_p_f_void__p_void swig_types[580]
#define SWIGTYPE_p_float swig_types[581]
#define SWIGTYPE_p_floatp swig_types[582]
#define SWIGTYPE_p_int swig_types[583]
#define SWIGTYPE_p_intp swig_types[584]
#define SWIGTYPE_p_long swig_types[585]
#define SWIGTYPE_p_long_long swig_types[586]
#define SWIGTYPE_p_longp swig_types[587]
#define SWIGTYPE_p_open_func swig_types[588]
#define SWIGTYPE_p_p_SoEngineOutput swig_types[589]
#define SWIGTYPE_p_p_SoField swig_types[590]
#define SWIGTYPE_p_p_SoMFBitMask swig_types[591]
#define SWIGTYPE_p_p_SoMFBool swig_types[592]
#define SWIGTYPE_p_p_SoMFColor swig_types[593]
#define SWIGTYPE_p_p_SoMFColorRGBA swig_types[594]
#define SWIGTYPE_p_p_SoMFDouble swig_types[595]
#define SWIGTYPE_p_p_SoMFEngine swig_types[596]
#define SWIGTYPE_p_p_SoMFEnum swig_types[597]
#define SWIGTYPE_p_p_SoMFFloat swig_types[598]
#define SWIGTYPE_p_p_SoMFInt32 swig_types[599]
#define SWIGTYPE_p_p_SoMFMatrix swig_types[600]
#define SWIGTYPE_p_p_SoMFName swig_types[601]
#define SWIGTYPE_p_p_SoMFNode swig_types[602]
#define SWIGTYPE_p_p_SoMFPath swig_types[603]
#define SWIGTYPE_p_p_SoMFPlane swig_types[604]
#define SWIGTYPE_p_p_SoMFRotation swig_types[605]
#define SWIGTYPE_p_p_SoMFShort swig_types[606]
#define SWIGTYPE_p_p_SoMFString swig_types[607]
#define SWIGTYPE_p_p_SoMFTime swig_types[608]
#define SWIGTYPE_p_p_SoMFUInt32 swig_types[609]
#define SWIGTYPE_p_p_SoMFUShort swig_types[610]
#define SWIGTYPE_p_p_SoMFVec2b swig_types[611]
#define SWIGTYPE_p_p_SoMFVec2d swig_types[612]
#define SWIGTYPE_p_p_SoMFVec2f swig_types[613]
#define SWIGTYPE_p_p_SoMFVec2i32 swig_types[614]
#define SWIGTYPE_p_p_SoMFVec2s swig_types[615]
#define SWIGTYPE_p_p_SoMFVec3b swig_types[616]
#define SWIGTYPE_p_p_SoMFVec3d swig_types[617]
#define SWIGTYPE_p_p_SoMFVec3f swig_types[618]
#define SWIGTYPE_p_p_SoMFVec3i32 swig_types[619]
#define SWIGTYPE_p_p_SoMFVec3s swig_types[620]
#define SWIGTYPE_p_p_SoMFVec4b swig_types[621]
#define SWIGTYPE_p_p_SoMFVec4d swig_types[622]
#define SWIGTYPE_p_p_SoMFVec4f swig_types[623]
#define SWIGTYPE_p_p_SoMFVec4i32 swig_types[624]
#define SWIGTYPE_p_p_SoMFVec4s swig_types[625]
#define SWIGTYPE_p_p_SoMFVec4ub swig_types[626]
#define SWIGTYPE_p_p_SoMFVec4ui32 swig_types[627]
#define SWIGTYPE_p_p_SoMFVec4us swig_types[628]
#define SWIGTYPE_p_p_SoMField swig_types[629]
#define SWIGTYPE_p_p_SoSFBitMask swig_types[630]
#define SWIGTYPE_p_p_SoSFBool swig_types[631]
#define SWIGTYPE_p_p_SoSFBox2d swig_types[632]
#define SWIGTYPE_p_p_SoSFBox2f swig_types[633]
#define SWIGTYPE_p_p_SoSFBox2i32 swig_types[634]
#define SWIGTYPE_p_p_SoSFBox2s swig_types[635]
#define SWIGTYPE_p_p_SoSFBox3d swig_types[636]
#define SWIGTYPE_p_p_SoSFBox3f swig_types[637]
#define SWIGTYPE_p_p_SoSFBox3i32 swig_types[638]
#define SWIGTYPE_p_p_SoSFBox3s swig_types[639]
#define SWIGTYPE_p_p_SoSFColor swig_types[640]
#define SWIGTYPE_p_p_SoSFColorRGBA swig_types[641]
#define SWIGTYPE_p_p_SoSFDouble swig_types[642]
#define SWIGTYPE_p_p_SoSFEngine swig_types[643]
#define SWIGTYPE_p_p_SoSFEnum swig_types[644]
#define SWIGTYPE_p_p_SoSFFloat swig_types[645]
#define SWIGTYPE_p_p_SoSFImage swig_types[646]
#define SWIGTYPE_p_p_SoSFImage3 swig_types[647]
#define SWIGTYPE_p_p_SoSFInt32 swig_types[648]
#define SWIGTYPE_p_p_SoSFMatrix swig_types[649]
#define SWIGTYPE_p_p_SoSFName swig_types[650]
#define SWIGTYPE_p_p_SoSFNode swig_types[651]
#define SWIGTYPE_p_p_SoSFPath swig_types[652]
#define SWIGTYPE_p_p_SoSFPlane swig_types[653]
#define SWIGTYPE_p_p_SoSFRotation swig_types[654]
#define SWIGTYPE_p_p_SoSFShort swig_types[655]
#define SWIGTYPE_p_p_SoSFString swig_types[656]
#define SWIGTYPE_p_p_SoSFTime swig_types[657]
#define SWIGTYPE_p_p_SoSFTrigger swig_types[658]
#define SWIGTYPE_p_p_SoSFUInt32 swig_types[659]
#define SWIGTYPE_p_p_SoSFUShort swig_types[660]
#define SWIGTYPE_p_p_SoSFVec2b swig_types[661]
#define SWIGTYPE_p_p_SoSFVec2d swig_types[662]
#define SWIGTYPE_p_p_SoSFVec2f swig_types[663]
#define SWIGTYPE_p_p_SoSFVec2i32 swig_types[664]
#define SWIGTYPE_p_p_SoSFVec2s swig_types[665]
#define SWIGTYPE_p_p_SoSFVec3b swig_types[666]
#define SWIGTYPE_p_p_SoSFVec3d swig_types[667]
#define SWIGTYPE_p_p_SoSFVec3f swig_types[668]
#define SWIGTYPE_p_p_SoSFVec3i32 swig_types[669]
#define SWIGTYPE_p_p_SoSFVec3s swig_types[670]
#define SWIGTYPE_p_p_SoSFVec4b swig_types[671]
#define SWIGTYPE_p_p_SoSFVec4d swig_types[672]
#define SWIGTYPE_p_p_SoSFVec4f swig_types[673]
#define SWIGTYPE_p_p_SoSFVec4i32 swig_types[674]
#define SWIGTYPE_p_p_SoSFVec4s swig_types[675]
#define SWIGTYPE_p_p_SoSFVec4ub swig_types[676]
#define SWIGTYPE_p_p_SoSFVec4ui32 swig_types[677]
#define SWIGTYPE_p_p_SoSFVec4us swig_types[678]
#define SWIGTYPE_p_p_SoSField swig_types[679]
#define SWIGTYPE_p_p_char swig_types[680]
#define SWIGTYPE_p_p_charp swig_types[681]
#define SWIGTYPE_p_p_void swig_types[682]
#define SWIGTYPE_p_read_func swig_types[683]
#define SWIGTYPE_p_seek_func swig_types[684]
#define SWIGTYPE_p_short swig_types[685]
#define SWIGTYPE_p_signed_char swig_types[686]
#define SWIGTYPE_p_std__FILE swig_types[687]
#define SWIGTYPE_p_tell_func swig_types[688]
#define SWIGTYPE_p_time_t swig_types[689]
#define SWIGTYPE_p_timeval swig_types[690]
#define SWIGTYPE_p_unsigned_char swig_types[691]
#define SWIGTYPE_p_unsigned_int swig_types[692]
#define SWIGTYPE_p_unsigned_long_long swig_types[693]
#define SWIGTYPE_p_unsigned_short swig_types[694]
#define SWIGTYPE_p_void swig_types[695]
#define SWIGTYPE_p_wchar_t swig_types[696]
static swig_type_info *swig_types[698];
static swig_module_info swig_module = {swig_types, 697, 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):= _soqt.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__soqt

#else
#  define SWIG_init    init_soqt

#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;      
    }
  };
}


/*
  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 = NULL;

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


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

#include <Inventor/Qt/devices/SoQtDevice.h>
#include <Inventor/Qt/devices/SoQtKeyboard.h>
#include <Inventor/Qt/devices/SoQtMouse.h>
#include <Inventor/Qt/SoQtBasic.h>
#include <Inventor/Qt/SoQtComponent.h>
#include <Inventor/Qt/SoQtCursor.h>
#include <Inventor/Qt/SoQtGLWidget.h>
#include <Inventor/Qt/SoQt.h>
#include <Inventor/Qt/SoQtObject.h>
#include <Inventor/Qt/SoQtRenderArea.h>
#include <Inventor/Qt/viewers/SoQtConstrainedViewer.h>
#include <Inventor/Qt/viewers/SoQtExaminerViewer.h>
#include <Inventor/Qt/viewers/SoQtFlyViewer.h>
#include <Inventor/Qt/viewers/SoQtFullViewer.h>
#include <Inventor/Qt/viewers/SoQtPlaneViewer.h>
#include <Inventor/Qt/viewers/SoQtViewer.h>
#include <Inventor/Qt/widgets/SoQtPopupMenu.h>
#include <Inventor/Qt/widgets/SoQtThumbWheel.h>

#include "coin_header_includes.h"

/* make CustomCursor in SoQtCursor known to SWIG */
typedef SoQtCursor::CustomCursor CustomCursor;

/* FIXME: there is a major pitfall reg. this solution, namely
 * thread safety! reconsider! 20030626 tamer.
 */
static void *
Pivy_PythonInteractiveLoop(void *data) {
  PyRun_InteractiveLoop(stdin, "<stdin>");
  return NULL;
}

//////////////////////////////////////////////////////
//helper to get subclass name of qt-objects

# include <typeinfo>
#if __unix
#include <cxxabi.h>
template <typename T> const char* get_typename(T& object)
{
    return abi::__cxa_demangle(typeid(object).name(), 0, 0, 0);
}
#else
template <typename T> const char* get_typename(T& object)
{
    return (typeid(object).name() + 6);  // the +6 advanced the pointer 6 bytes (6 asc ii characters) to cut off prefix "class " from the object's class name
}
#endif
/////////////////////////////////////////////////////

#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
#define SHIBOKEN "shiboken6"
#else
#define SHIBOKEN "shiboken2"
#endif

static const char * PYSIDE_QT = "pivy.gui.qt";

static PyObject* getShiboken()
{

  // this function assumes shiboken is available directly
  // pip installs it in a wrong place
  // if you have installed shiboken with pip please symlink to correct directory
  PyObject * shiboken = NULL;
  if (!(shiboken = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), SHIBOKEN))) {
    // simple import shiboken from python.
   shiboken = PyImport_ImportModule(SHIBOKEN);
  }
  return shiboken;
}



#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 SoQt_mainLoop(){
    PyRun_SimpleString("import sys");
    PyObject *d = PyModule_GetDict(PyImport_AddModule("__main__"));
    PyObject *result = PyRun_String("sys.argv[0]", Py_eval_input, d, d);
    /* if we are calling from within an interactive python interpreter
     * session spawn a new InteractiveLoop in a new thread. determined
     * by sys.argv[0] == ''. otherwise proceed as usual.
     */




    if (!strcmp(PyUnicode_AsUTF8(result), ""))

    {
      cc_thread *py_thread = cc_thread_construct(Pivy_PythonInteractiveLoop, NULL);
      SoQt::mainLoop();
      void *retval = NULL;
      cc_thread_join(py_thread, &retval);
      cc_thread_destruct(py_thread);
      Py_Exit(0);
    } else 
    {
      SoQt::mainLoop();
    }
  }


static SbBool
SoQtRenderAreaEventPythonCB(void * closure, QEvent * event)
{
  PyObject *func = NULL, *arglist = NULL;
  PyObject *result = NULL, *shiboken, *qt = NULL, *qev = NULL;
  SbBool ret = TRUE; // assume success as default

  /* try to create a QEvent PySide instance over shiboken */

  /* check if the shiboken module is available and import it */
  shiboken = getShiboken();

  if (shiboken && PyModule_Check(shiboken)) {
    /* check if the qt module is available and import it */
    if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
      qt = PyImport_ImportModule(PYSIDE_QT);
    }

    if (qt && PyModule_Check(qt)) {
      /* grab the wrapinstance(addr, type) function */
      PyObject *shiboken_wrapinst_func = NULL;
      shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
      if (PyCallable_Check(shiboken_wrapinst_func)) {
        PyObject *qevent_type = NULL;
        qevent_type = PyDict_GetItemString(PyModule_GetDict(qt), get_typename(*event));

        // TODO: find better solution for QKeyEvent
        if (!qevent_type){
          if (strcmp(get_typename(*event), "QKeyEventEx") == 0) {
            qevent_type = PyDict_GetItemString(PyModule_GetDict(qt), "QKeyEvent");
          } else {
            qevent_type = PyDict_GetItemString(PyModule_GetDict(qt), "QEvent");
          }
        }

        if (qevent_type)
        {
          arglist = Py_BuildValue("(nO)", event, qevent_type);

          if (!(qev = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
            PyErr_Print();
          }

          Py_DECREF(arglist);
        }
      }
    }
  }

  /* if no QEvent could be created through shiboken return a swig QEvent type */
  if (!qev) {
    qev = SWIG_NewPointerObj((void *)event, SWIGTYPE_p_QEvent, 0);
  }

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

  if (!(result = PyObject_CallObject(func, arglist))) {
    PyErr_Print();
  } else {
    ret = FALSE;
  }

  if (shiboken) {
    Py_DECREF(shiboken);
  }
  Py_DECREF(arglist);
  Py_DECREF(qev);
  Py_XDECREF(result);

  return ret;
}

SWIGINTERN void SoQtRenderArea_setEventCallback__SWIG_2(SoQtRenderArea *self,PyObject *pyfunc,PyObject *user=NULL){
    self->setEventCallback(SoQtRenderAreaEventPythonCB,
                           (void *)Py_BuildValue("(OO)",
                                                 pyfunc,
                                                 user ? user : 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_delete_QEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QEvent *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    {
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* grab the unwrapInstance(obj) function */
        PyObject *shiboken_unwrapinst_func = NULL;
        shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
        
        if (PyCallable_Check(shiboken_unwrapinst_func)) {
          PyObject *arglist = NULL, *address = NULL;
          arglist = Py_BuildValue("(O)", swig_obj[0]);
          if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
            PyErr_Print();
          } else if (PyNumber_Check(address)) {
            arg1 = (QEvent*)PyLong_AsVoidPtr(address);
          } else if (PyTuple_Check(address)) {
            arg1 = (QEvent*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
          }
          
          Py_DECREF(arglist);
        }
      }
    }
    
    if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
      PyErr_Clear();
      if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QEvent, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    }
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_delete_QWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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


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


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


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


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


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


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

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


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


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


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


SWIGINTERN PyObject *_wrap_SoQtDevice_enable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtDevice *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  SoQtEventHandler *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtDevice_enable", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtDevice_enable" "', argument " "1"" of type '" "SoQtDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoQtDevice * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_QWidget_p_void_p_QEvent_p_bool__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtDevice_enable" "', argument " "3"" of type '" "SoQtEventHandler *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQtDevice_enable" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->enable(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtDevice_disable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtDevice *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  SoQtEventHandler *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtDevice_disable", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtDevice_disable" "', argument " "1"" of type '" "SoQtDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoQtDevice * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_QWidget_p_void_p_QEvent_p_bool__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtDevice_disable" "', argument " "3"" of type '" "SoQtEventHandler *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQtDevice_disable" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->disable(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtDevice_translateEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtDevice *arg1 = 0 ;
  QEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtDevice_translateEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtDevice_translateEvent" "', argument " "1"" of type '" "SoQtDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoQtDevice * >(argp1);
  {
    {
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* grab the unwrapInstance(obj) function */
        PyObject *shiboken_unwrapinst_func = NULL;
        shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
        
        if (PyCallable_Check(shiboken_unwrapinst_func)) {
          PyObject *arglist = NULL, *address = NULL;
          arglist = Py_BuildValue("(O)", swig_obj[1]);
          if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
            PyErr_Print();
          } else if (PyNumber_Check(address)) {
            arg2 = (QEvent*)PyLong_AsVoidPtr(address);
          } else if (PyTuple_Check(address)) {
            arg2 = (QEvent*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
          }
          
          Py_DECREF(arglist);
        }
      }
    }
    
    if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
      PyErr_Clear();
      if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QEvent, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    }
  }
  result = (SoEvent *)(arg1)->translateEvent(arg2);
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtDevice_setWindowSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtDevice *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtDevice_setWindowSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtDevice_setWindowSize" "', argument " "1"" of type '" "SoQtDevice *""'"); 
  }
  arg1 = reinterpret_cast< SoQtDevice * >(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 '" "SoQtDevice_setWindowSize" "', argument " "2"" of type '" "SbVec2s const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtDevice_setWindowSize" "', argument " "2"" of type '" "SbVec2s const""'");
    } 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_SoQtDevice_getWindowSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtDevice *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_SoQtDevice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtDevice_getWindowSize" "', argument " "1"" of type '" "SoQtDevice const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtDevice * >(argp1);
  result = ((SoQtDevice const *)arg1)->getWindowSize();
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtKeyboard_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtKeyboard_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoQtKeyboard::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoQtKeyboard__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoQtKeyboard *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_SoQtKeyboard" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoQtKeyboard *)new SoQtKeyboard(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtKeyboard, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_SoQtKeyboard(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoQtKeyboard", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoQtKeyboard__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_SoQtKeyboard__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoQtKeyboard'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtKeyboard::SoQtKeyboard(int)\n"
    "    SoQtKeyboard::SoQtKeyboard()\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_SoQtKeyboard_enable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtKeyboard *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  SoQtEventHandler *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtKeyboard_enable", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtKeyboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtKeyboard_enable" "', argument " "1"" of type '" "SoQtKeyboard *""'"); 
  }
  arg1 = reinterpret_cast< SoQtKeyboard * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_QWidget_p_void_p_QEvent_p_bool__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtKeyboard_enable" "', argument " "3"" of type '" "SoQtEventHandler *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQtKeyboard_enable" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->enable(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtKeyboard_disable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtKeyboard *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  SoQtEventHandler *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtKeyboard_disable", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtKeyboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtKeyboard_disable" "', argument " "1"" of type '" "SoQtKeyboard *""'"); 
  }
  arg1 = reinterpret_cast< SoQtKeyboard * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_QWidget_p_void_p_QEvent_p_bool__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtKeyboard_disable" "', argument " "3"" of type '" "SoQtEventHandler *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQtKeyboard_disable" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->disable(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtKeyboard_translateEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtKeyboard *arg1 = 0 ;
  QEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtKeyboard_translateEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtKeyboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtKeyboard_translateEvent" "', argument " "1"" of type '" "SoQtKeyboard *""'"); 
  }
  arg1 = reinterpret_cast< SoQtKeyboard * >(argp1);
  {
    {
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* grab the unwrapInstance(obj) function */
        PyObject *shiboken_unwrapinst_func = NULL;
        shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
        
        if (PyCallable_Check(shiboken_unwrapinst_func)) {
          PyObject *arglist = NULL, *address = NULL;
          arglist = Py_BuildValue("(O)", swig_obj[1]);
          if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
            PyErr_Print();
          } else if (PyNumber_Check(address)) {
            arg2 = (QEvent*)PyLong_AsVoidPtr(address);
          } else if (PyTuple_Check(address)) {
            arg2 = (QEvent*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
          }
          
          Py_DECREF(arglist);
        }
      }
    }
    
    if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
      PyErr_Clear();
      if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QEvent, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    }
  }
  result = (SoEvent *)(arg1)->translateEvent(arg2);
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


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

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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtMouse_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtMouse_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoQtMouse::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoQtMouse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoQtMouse *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_SoQtMouse" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (SoQtMouse *)new SoQtMouse(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtMouse, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_SoQtMouse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoQtMouse", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoQtMouse__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_SoQtMouse__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoQtMouse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtMouse::SoQtMouse(int)\n"
    "    SoQtMouse::SoQtMouse()\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_SoQtMouse_enable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtMouse *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  SoQtEventHandler *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtMouse_enable", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtMouse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtMouse_enable" "', argument " "1"" of type '" "SoQtMouse *""'"); 
  }
  arg1 = reinterpret_cast< SoQtMouse * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_QWidget_p_void_p_QEvent_p_bool__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtMouse_enable" "', argument " "3"" of type '" "SoQtEventHandler *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQtMouse_enable" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->enable(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtMouse_disable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtMouse *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  SoQtEventHandler *arg3 = 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res4 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtMouse_disable", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtMouse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtMouse_disable" "', argument " "1"" of type '" "SoQtMouse *""'"); 
  }
  arg1 = reinterpret_cast< SoQtMouse * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_p_QWidget_p_void_p_QEvent_p_bool__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtMouse_disable" "', argument " "3"" of type '" "SoQtEventHandler *""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQtMouse_disable" "', argument " "4"" of type '" "void *""'"); 
  }
  (arg1)->disable(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtMouse_translateEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtMouse *arg1 = 0 ;
  QEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  SoEvent *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtMouse_translateEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtMouse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtMouse_translateEvent" "', argument " "1"" of type '" "SoQtMouse *""'"); 
  }
  arg1 = reinterpret_cast< SoQtMouse * >(argp1);
  {
    {
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* grab the unwrapInstance(obj) function */
        PyObject *shiboken_unwrapinst_func = NULL;
        shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
        
        if (PyCallable_Check(shiboken_unwrapinst_func)) {
          PyObject *arglist = NULL, *address = NULL;
          arglist = Py_BuildValue("(O)", swig_obj[1]);
          if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
            PyErr_Print();
          } else if (PyNumber_Check(address)) {
            arg2 = (QEvent*)PyLong_AsVoidPtr(address);
          } else if (PyTuple_Check(address)) {
            arg2 = (QEvent*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
          }
          
          Py_DECREF(arglist);
        }
      }
    }
    
    if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
      PyErr_Clear();
      if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QEvent, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    }
  }
  result = (SoEvent *)(arg1)->translateEvent(arg2);
  {
    resultobj = autocast_event(result);
  }
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_SoQt_init__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 ;
  QWidget *result = 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 '" "SoQt_init" "', 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 '" "SoQt_init" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (QWidget *)SoQt::init((char const *)arg1,(char const *)arg2);
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  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_SoQt_init__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 ;
  QWidget *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 '" "SoQt_init" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (QWidget *)SoQt::init((char const *)arg1);
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_init__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  char **arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  QWidget *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQt_init" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQt_init" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(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 '" "SoQt_init" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQt_init" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQt_init" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  result = (QWidget *)SoQt::init(*arg1,arg2,(char const *)arg3,(char const *)arg4);
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_init__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  char **arg2 = 0 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  QWidget *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQt_init" "', argument " "1"" of type '" "int &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQt_init" "', argument " "1"" of type '" "int &""'"); 
  }
  arg1 = reinterpret_cast< int * >(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 '" "SoQt_init" "', argument " "2"" of type '" "char **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQt_init" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (QWidget *)SoQt::init(*arg1,arg2,(char const *)arg3);
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_init__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  SoQt::init(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQt_init", 0, 4, 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_SoQt_init__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      return _wrap_SoQt_init__SWIG_4(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_SoQt_init__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoQt_init__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoQt_init__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQt_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQt::init(char const *,char const *)\n"
    "    SoQt::init(char const *)\n"
    "    SoQt::init(int &,char **,char const *,char const *)\n"
    "    SoQt::init(int &,char **,char const *)\n"
    "    SoQt::init(QWidget *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQt_exitMainLoop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_exitMainLoop", 0, 0, 0)) SWIG_fail;
  SoQt::exitMainLoop();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_done(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_done", 0, 0, 0)) SWIG_fail;
  SoQt::done();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getTopLevelWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_getTopLevelWidget", 0, 0, 0)) SWIG_fail;
  result = (QWidget *)SoQt::getTopLevelWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getShellWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = (QWidget *)SoQt::getShellWidget((QWidget const *)arg1);
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_show(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = (QWidget *)0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  SoQt::show(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_hide(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = (QWidget *)0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  SoQt::hide(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_setWidgetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = (QWidget *)0 ;
  SbVec2s arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_setWidgetSize", 2, 2, swig_obj)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2s,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQt_setWidgetSize" "', argument " "2"" of type '" "SbVec2s const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQt_setWidgetSize" "', argument " "2"" of type '" "SbVec2s const""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  SoQt::setWidgetSize(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getWidgetSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  SbVec2s result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = SoQt::getWidgetSize((QWidget const *)arg1);
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_createSimpleErrorDialog__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQt_createSimpleErrorDialog" "', 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 '" "SoQt_createSimpleErrorDialog" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SoQt_createSimpleErrorDialog" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  SoQt::createSimpleErrorDialog(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_createSimpleErrorDialog__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQt_createSimpleErrorDialog" "', 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 '" "SoQt_createSimpleErrorDialog" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  SoQt::createSimpleErrorDialog(arg1,(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_SoQt_createSimpleErrorDialog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQt_createSimpleErrorDialog", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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_SoQt_createSimpleErrorDialog__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoQt_createSimpleErrorDialog__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQt_createSimpleErrorDialog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQt::createSimpleErrorDialog(QWidget *,char const *,char const *,char const *)\n"
    "    SoQt::createSimpleErrorDialog(QWidget *,char const *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQt_getVersionInfo__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *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 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) 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 '" "SoQt_getVersionInfo" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(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 '" "SoQt_getVersionInfo" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQt_getVersionInfo" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  SoQt::getVersionInfo(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getVersionInfo__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  int *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_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQt_getVersionInfo" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(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 '" "SoQt_getVersionInfo" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  SoQt::getVersionInfo(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getVersionInfo__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int *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_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQt_getVersionInfo" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  SoQt::getVersionInfo(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getVersionInfo__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  SoQt::getVersionInfo();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getVersionInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQt_getVersionInfo", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_SoQt_getVersionInfo__SWIG_3(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_SoQt_getVersionInfo__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 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_SoQt_getVersionInfo__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SoQt_getVersionInfo__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQt_getVersionInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQt::getVersionInfo(int *,int *,int *)\n"
    "    SoQt::getVersionInfo(int *,int *)\n"
    "    SoQt::getVersionInfo(int *)\n"
    "    SoQt::getVersionInfo()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQt_getVersionString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_getVersionString", 0, 0, 0)) SWIG_fail;
  result = (char *)SoQt::getVersionString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getVersionToolkitString(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_getVersionToolkitString", 0, 0, 0)) SWIG_fail;
  result = (char *)SoQt::getVersionToolkitString();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_setFatalErrorHandler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQt::FatalErrorCB *arg1 = 0 ;
  void *arg2 = 0 ;
  int res2 ;
  PyObject *swig_obj[2] ;
  SoQt::FatalErrorCB *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_setFatalErrorHandler", 2, 2, swig_obj)) SWIG_fail;
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[0], (void**)(&arg1), SWIGTYPE_p_f_q_const__SbString_enum_SoQt__FatalErrors_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQt_setFatalErrorHandler" "', argument " "1"" of type '" "SoQt::FatalErrorCB *""'"); 
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQt_setFatalErrorHandler" "', argument " "2"" of type '" "void *""'"); 
  }
  result = (SoQt::FatalErrorCB *)SoQt::setFatalErrorHandler(arg1,arg2);
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_q_const__SbString_enum_SoQt__FatalErrors_p_void__void);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_isDebugLibrary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_isDebugLibrary", 0, 0, 0)) SWIG_fail;
  result = (SbBool)SoQt::isDebugLibrary();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_isCompatible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SbBool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_isCompatible", 2, 2, 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 '" "SoQt_isCompatible" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQt_isCompatible" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (SbBool)SoQt::isCompatible(arg1,arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_getABIType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQt::ABIType result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_getABIType", 0, 0, 0)) SWIG_fail;
  result = (SoQt::ABIType)SoQt::getABIType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_lockGL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_lockGL", 0, 0, 0)) SWIG_fail;
  SoQt::lockGL();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQt_unlockGL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQt_unlockGL", 0, 0, 0)) SWIG_fail;
  SoQt::unlockGL();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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

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


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


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


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


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


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


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


SWIGINTERN PyObject *_wrap_SoQtComponent_setWidgetCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  SoQtCursor *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtComponent_setWidgetCursor", 2, 2, swig_obj)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SoQtCursor,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtComponent_setWidgetCursor" "', argument " "2"" of type '" "SoQtCursor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtComponent_setWidgetCursor" "', argument " "2"" of type '" "SoQtCursor const &""'"); 
  }
  arg2 = reinterpret_cast< SoQtCursor * >(argp2);
  SoQtComponent::setWidgetCursor(arg1,(SoQtCursor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_isFullScreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_isFullScreen" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (SbBool)((SoQtComponent const *)arg1)->isFullScreen();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_setFullScreen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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, "SoQtComponent_setFullScreen", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_setFullScreen" "', argument " "1"" of type '" "SoQtComponent *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtComponent_setFullScreen" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  result = (SbBool)(arg1)->setFullScreen(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_isVisible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_isVisible" "', argument " "1"" of type '" "SoQtComponent *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (SbBool)(arg1)->isVisible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_isTopLevelShell(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_isTopLevelShell" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (SbBool)((SoQtComponent const *)arg1)->isTopLevelShell();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getWidget" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (QWidget *)((SoQtComponent const *)arg1)->getWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getBaseWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getBaseWidget" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (QWidget *)((SoQtComponent const *)arg1)->getBaseWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getShellWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getShellWidget" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (QWidget *)((SoQtComponent const *)arg1)->getShellWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getParentWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getParentWidget" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (QWidget *)((SoQtComponent const *)arg1)->getParentWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_setSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 0 ;
  SbVec2s arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtComponent_setSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_setSize" "', argument " "1"" of type '" "SoQtComponent *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(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 '" "SoQtComponent_setSize" "', argument " "2"" of type '" "SbVec2s const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtComponent_setSize" "', argument " "2"" of type '" "SbVec2s const""'");
    } else {
      SbVec2s * temp = reinterpret_cast< SbVec2s * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setSize(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getSize" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = ((SoQtComponent const *)arg1)->getSize();
  resultobj = SWIG_NewPointerObj((new SbVec2s(result)), SWIGTYPE_p_SbVec2s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_setTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 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, "SoQtComponent_setTitle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_setTitle" "', argument " "1"" of type '" "SoQtComponent *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtComponent_setTitle" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setTitle((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_SoQtComponent_getTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getTitle" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (char *)((SoQtComponent const *)arg1)->getTitle();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_setIconTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 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, "SoQtComponent_setIconTitle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_setIconTitle" "', argument " "1"" of type '" "SoQtComponent *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtComponent_setIconTitle" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->setIconTitle((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_SoQtComponent_getIconTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getIconTitle" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (char *)((SoQtComponent const *)arg1)->getIconTitle();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getWidgetName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getWidgetName" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (char *)((SoQtComponent const *)arg1)->getWidgetName();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getClassName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtComponent *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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_getClassName" "', argument " "1"" of type '" "SoQtComponent const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  result = (char *)((SoQtComponent const *)arg1)->getClassName();
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_setWindowCloseCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 0 ;
  SoQtComponentCB *arg2 = (SoQtComponentCB *)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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_setWindowCloseCallback" "', argument " "1"" of type '" "SoQtComponent *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtComponent__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtComponent_setWindowCloseCallback" "', argument " "2"" of type '" "SoQtComponentCB *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 '" "SoQtComponent_setWindowCloseCallback" "', argument " "3"" of type '" "void *const""'"); 
  }
  (arg1)->setWindowCloseCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_setWindowCloseCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtComponent *arg1 = 0 ;
  SoQtComponentCB *arg2 = (SoQtComponentCB *)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_SoQtComponent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtComponent_setWindowCloseCallback" "', argument " "1"" of type '" "SoQtComponent *""'"); 
  }
  arg1 = reinterpret_cast< SoQtComponent * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtComponent__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtComponent_setWindowCloseCallback" "', argument " "2"" of type '" "SoQtComponentCB *const""'"); 
    }
  }
  (arg1)->setWindowCloseCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_setWindowCloseCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtComponent_setWindowCloseCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtComponent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtComponent__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtComponent_setWindowCloseCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtComponent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtComponent__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_SoQtComponent_setWindowCloseCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtComponent_setWindowCloseCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtComponent::setWindowCloseCallback(SoQtComponentCB *const,void *const)\n"
    "    SoQtComponent::setWindowCloseCallback(SoQtComponentCB *const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtComponent_getComponent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  PyObject *swig_obj[1] ;
  SoQtComponent *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = (SoQtComponent *)SoQtComponent::getComponent(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtComponent, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setBorder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setBorder", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setBorder" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setBorder" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setBorder(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_isBorder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_isBorder" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->isBorder();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setDoubleBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setDoubleBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setDoubleBuffer" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_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_SoQtGLWidget_isDoubleBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_isDoubleBuffer" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->isDoubleBuffer();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setDrawToFrontBufferEnable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setDrawToFrontBufferEnable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setDrawToFrontBufferEnable" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setDrawToFrontBufferEnable" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDrawToFrontBufferEnable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_isDrawToFrontBufferEnable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_isDrawToFrontBufferEnable" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->isDrawToFrontBufferEnable();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setQuadBufferStereo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setQuadBufferStereo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setQuadBufferStereo" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setQuadBufferStereo" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setQuadBufferStereo(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_isQuadBufferStereo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_isQuadBufferStereo" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->isQuadBufferStereo();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setAccumulationBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setAccumulationBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setAccumulationBuffer" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setAccumulationBuffer" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setAccumulationBuffer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getAccumulationBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getAccumulationBuffer" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->getAccumulationBuffer();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setStencilBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setStencilBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setStencilBuffer" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setStencilBuffer" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setStencilBuffer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getStencilBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getStencilBuffer" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->getStencilBuffer();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setAlphaChannel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setAlphaChannel", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setAlphaChannel" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setAlphaChannel" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setAlphaChannel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getAlphaChannel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getAlphaChannel" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->getAlphaChannel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setOverlayRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setOverlayRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setOverlayRender" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setOverlayRender" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setOverlayRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_isOverlayRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_isOverlayRender" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->isOverlayRender();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setSampleBuffers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setSampleBuffers", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setSampleBuffers" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setSampleBuffers" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setSampleBuffers(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getSampleBuffers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getSampleBuffers" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (int)((SoQtGLWidget const *)arg1)->getSampleBuffers();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_setStealFocus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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, "SoQtGLWidget_setStealFocus", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_setStealFocus" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtGLWidget_setStealFocus" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setStealFocus(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_isStealFocus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_isStealFocus" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->isStealFocus();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getGLWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getGLWidget" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (QWidget *)((SoQtGLWidget const *)arg1)->getGLWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getNormalWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getNormalWidget" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (QWidget *)((SoQtGLWidget const *)arg1)->getNormalWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getOverlayWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getOverlayWidget" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (QWidget *)((SoQtGLWidget const *)arg1)->getOverlayWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_hasOverlayGLArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_hasOverlayGLArea" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->hasOverlayGLArea();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_hasNormalGLArea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_hasNormalGLArea" "', argument " "1"" of type '" "SoQtGLWidget const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (SbBool)((SoQtGLWidget const *)arg1)->hasNormalGLArea();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getOverlayTransparentPixel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *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_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getOverlayTransparentPixel" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  result = (unsigned long)(arg1)->getOverlayTransparentPixel();
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getPointSizeLimits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *arg1 = 0 ;
  SbVec2f *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, "SoQtGLWidget_getPointSizeLimits", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getPointSizeLimits" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtGLWidget_getPointSizeLimits" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtGLWidget_getPointSizeLimits" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQtGLWidget_getPointSizeLimits" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtGLWidget_getPointSizeLimits" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  (arg1)->getPointSizeLimits(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtGLWidget_getLineWidthLimits(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtGLWidget *arg1 = 0 ;
  SbVec2f *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, "SoQtGLWidget_getLineWidthLimits", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtGLWidget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtGLWidget_getLineWidthLimits" "', argument " "1"" of type '" "SoQtGLWidget *""'"); 
  }
  arg1 = reinterpret_cast< SoQtGLWidget * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SbVec2f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtGLWidget_getLineWidthLimits" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtGLWidget_getLineWidthLimits" "', argument " "2"" of type '" "SbVec2f &""'"); 
  }
  arg2 = reinterpret_cast< SbVec2f * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQtGLWidget_getLineWidthLimits" "', argument " "3"" of type '" "float &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtGLWidget_getLineWidthLimits" "', argument " "3"" of type '" "float &""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  (arg1)->getLineWidthLimits(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtRenderArea_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoQtRenderArea::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoQtRenderArea__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  SbBool arg5 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SoQtRenderArea *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtRenderArea" "', 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 '" "new_SoQtRenderArea" "', 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 '" "new_SoQtRenderArea" "', 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 '" "new_SoQtRenderArea" "', argument " "5"" of type '" "SbBool""'");
  } 
  arg5 = static_cast< SbBool >(val5);
  result = (SoQtRenderArea *)new SoQtRenderArea(arg1,(char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtRenderArea, 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_SoQtRenderArea__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  SbBool arg4 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SoQtRenderArea *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtRenderArea" "', 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 '" "new_SoQtRenderArea" "', 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 '" "new_SoQtRenderArea" "', argument " "4"" of type '" "SbBool""'");
  } 
  arg4 = static_cast< SbBool >(val4);
  result = (SoQtRenderArea *)new SoQtRenderArea(arg1,(char const *)arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtRenderArea, 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_SoQtRenderArea__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoQtRenderArea *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtRenderArea" "', 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 '" "new_SoQtRenderArea" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoQtRenderArea *)new SoQtRenderArea(arg1,(char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtRenderArea, 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_SoQtRenderArea__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SoQtRenderArea *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtRenderArea" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SoQtRenderArea *)new SoQtRenderArea(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtRenderArea, 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_SoQtRenderArea__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  SoQtRenderArea *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = (SoQtRenderArea *)new SoQtRenderArea(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtRenderArea, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_SoQtRenderArea(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoQtRenderArea", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoQtRenderArea__SWIG_5(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      return _wrap_new_SoQtRenderArea__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SoQtRenderArea__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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_new_SoQtRenderArea__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SoQtRenderArea__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            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_new_SoQtRenderArea__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoQtRenderArea'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtRenderArea::SoQtRenderArea(QWidget *,char const *,SbBool,SbBool,SbBool)\n"
    "    SoQtRenderArea::SoQtRenderArea(QWidget *,char const *,SbBool,SbBool)\n"
    "    SoQtRenderArea::SoQtRenderArea(QWidget *,char const *,SbBool)\n"
    "    SoQtRenderArea::SoQtRenderArea(QWidget *,char const *)\n"
    "    SoQtRenderArea::SoQtRenderArea(QWidget *)\n"
    "    SoQtRenderArea::SoQtRenderArea()\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setSceneGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setSceneGraph" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_setSceneGraph" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setSceneGraph(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_getSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getSceneGraph" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SoNode *)(arg1)->getSceneGraph();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setOverlaySceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setOverlaySceneGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setOverlaySceneGraph" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_setOverlaySceneGraph" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setOverlaySceneGraph(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_getOverlaySceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getOverlaySceneGraph" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SoNode *)(arg1)->getOverlaySceneGraph();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setBackgroundColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setBackgroundColor" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(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 '" "SoQtRenderArea_setBackgroundColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtRenderArea_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_SoQtRenderArea_getBackgroundColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getBackgroundColor" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SbColor *) &((SoQtRenderArea const *)arg1)->getBackgroundColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setBackgroundIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setBackgroundIndex" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_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_SoQtRenderArea_getBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getBackgroundIndex" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (int)((SoQtRenderArea const *)arg1)->getBackgroundIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setOverlayBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setOverlayBackgroundIndex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setOverlayBackgroundIndex" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_setOverlayBackgroundIndex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setOverlayBackgroundIndex(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_getOverlayBackgroundIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getOverlayBackgroundIndex" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (int)((SoQtRenderArea const *)arg1)->getOverlayBackgroundIndex();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setColorMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbColor *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, "SoQtRenderArea_setColorMap", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setColorMap" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_setColorMap" "', 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 '" "SoQtRenderArea_setColorMap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(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 '" "SoQtRenderArea_setColorMap" "', argument " "4"" of type '" "SbColor const *""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  (arg1)->setColorMap(arg2,arg3,(SbColor const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setOverlayColorMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  SbColor *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, "SoQtRenderArea_setOverlayColorMap", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setOverlayColorMap" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_setOverlayColorMap" "', 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 '" "SoQtRenderArea_setOverlayColorMap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(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 '" "SoQtRenderArea_setOverlayColorMap" "', argument " "4"" of type '" "SbColor const *""'"); 
  }
  arg4 = reinterpret_cast< SbColor * >(argp4);
  (arg1)->setOverlayColorMap(arg2,arg3,(SbColor const *)arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setViewportRegion", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setViewportRegion" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(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 '" "SoQtRenderArea_setViewportRegion" "', argument " "2"" of type '" "SbViewportRegion const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtRenderArea_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_SoQtRenderArea_getViewportRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getViewportRegion" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SbViewportRegion *) &((SoQtRenderArea const *)arg1)->getViewportRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbViewportRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setTransparencyType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setTransparencyType" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_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_SoQtRenderArea_getTransparencyType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getTransparencyType" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SoGLRenderAction::TransparencyType)((SoQtRenderArea const *)arg1)->getTransparencyType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setAntialiasing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setAntialiasing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setAntialiasing" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_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 '" "SoQtRenderArea_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_SoQtRenderArea_getAntialiasing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_getAntialiasing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getAntialiasing" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_getAntialiasing" "', argument " "2"" of type '" "SbBool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtRenderArea_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 '" "SoQtRenderArea_getAntialiasing" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtRenderArea_getAntialiasing" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ((SoQtRenderArea const *)arg1)->getAntialiasing(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setClearBeforeRender__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setClearBeforeRender" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_setClearBeforeRender" "', 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 '" "SoQtRenderArea_setClearBeforeRender" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setClearBeforeRender(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setClearBeforeRender__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setClearBeforeRender" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_setClearBeforeRender" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setClearBeforeRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setClearBeforeRender(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtRenderArea_setClearBeforeRender", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtRenderArea, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoQtRenderArea_setClearBeforeRender__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtRenderArea, 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_SoQtRenderArea_setClearBeforeRender__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtRenderArea_setClearBeforeRender'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtRenderArea::setClearBeforeRender(SbBool,SbBool)\n"
    "    SoQtRenderArea::setClearBeforeRender(SbBool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_isClearBeforeRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_isClearBeforeRender" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SbBool)((SoQtRenderArea const *)arg1)->isClearBeforeRender();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_isClearZBufferBeforeRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_isClearZBufferBeforeRender" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SbBool)((SoQtRenderArea const *)arg1)->isClearZBufferBeforeRender();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setClearBeforeOverlayRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setClearBeforeOverlayRender", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setClearBeforeOverlayRender" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_setClearBeforeOverlayRender" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setClearBeforeOverlayRender(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_isClearBeforeOverlayRender(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_isClearBeforeOverlayRender" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SbBool)((SoQtRenderArea const *)arg1)->isClearBeforeOverlayRender();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setAutoRedraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setAutoRedraw", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setAutoRedraw" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_setAutoRedraw" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setAutoRedraw(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_isAutoRedraw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_isAutoRedraw" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SbBool)((SoQtRenderArea const *)arg1)->isAutoRedraw();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setRedrawPriority", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setRedrawPriority" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtRenderArea_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_SoQtRenderArea_getRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getRedrawPriority" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (uint32_t)((SoQtRenderArea const *)arg1)->getRedrawPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_getDefaultRedrawPriority(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint32_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_getDefaultRedrawPriority", 0, 0, 0)) SWIG_fail;
  result = (uint32_t)SoQtRenderArea::getDefaultRedrawPriority();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


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


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


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


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


SWIGINTERN PyObject *_wrap_SoQtRenderArea_redrawOnSelectionChange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoSelection *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_redrawOnSelectionChange", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_redrawOnSelectionChange" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_redrawOnSelectionChange" "', argument " "2"" of type '" "SoSelection *""'"); 
  }
  arg2 = reinterpret_cast< SoSelection * >(argp2);
  (arg1)->redrawOnSelectionChange(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_redrawOverlayOnSelectionChange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoSelection *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_redrawOverlayOnSelectionChange", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_redrawOverlayOnSelectionChange" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSelection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_redrawOverlayOnSelectionChange" "', argument " "2"" of type '" "SoSelection *""'"); 
  }
  arg2 = reinterpret_cast< SoSelection * >(argp2);
  (arg1)->redrawOverlayOnSelectionChange(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setEventCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoQtRenderAreaEventCB *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setEventCallback" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_QEvent__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtRenderArea_setEventCallback" "', argument " "2"" of type '" "SoQtRenderAreaEventCB *""'"); 
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQtRenderArea_setEventCallback" "', argument " "3"" of type '" "void *""'"); 
  }
  (arg1)->setEventCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setEventCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoQtRenderAreaEventCB *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setEventCallback" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_QEvent__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtRenderArea_setEventCallback" "', argument " "2"" of type '" "SoQtRenderAreaEventCB *""'"); 
    }
  }
  (arg1)->setEventCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setSceneManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoSceneManager *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_setSceneManager", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setSceneManager" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_setSceneManager" "', argument " "2"" of type '" "SoSceneManager *""'"); 
  }
  arg2 = reinterpret_cast< SoSceneManager * >(argp2);
  (arg1)->setSceneManager(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_getSceneManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSceneManager *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getSceneManager" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SoSceneManager *)((SoQtRenderArea const *)arg1)->getSceneManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSceneManager, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setOverlaySceneManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoSceneManager *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_setOverlaySceneManager", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setOverlaySceneManager" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_setOverlaySceneManager" "', argument " "2"" of type '" "SoSceneManager *""'"); 
  }
  arg2 = reinterpret_cast< SoSceneManager * >(argp2);
  (arg1)->setOverlaySceneManager(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_getOverlaySceneManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoSceneManager *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getOverlaySceneManager" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SoSceneManager *)((SoQtRenderArea const *)arg1)->getOverlaySceneManager();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoSceneManager, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setGLRenderAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setGLRenderAction" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(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 '" "SoQtRenderArea_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_SoQtRenderArea_getGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getGLRenderAction" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SoGLRenderAction *)((SoQtRenderArea const *)arg1)->getGLRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setOverlayGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_setOverlayGLRenderAction", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setOverlayGLRenderAction" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(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 '" "SoQtRenderArea_setOverlayGLRenderAction" "', argument " "2"" of type '" "SoGLRenderAction *""'"); 
  }
  arg2 = reinterpret_cast< SoGLRenderAction * >(argp2);
  (arg1)->setOverlayGLRenderAction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_getOverlayGLRenderAction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_getOverlayGLRenderAction" "', argument " "1"" of type '" "SoQtRenderArea const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  result = (SoGLRenderAction *)((SoQtRenderArea const *)arg1)->getOverlayGLRenderAction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoGLRenderAction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_sendSoEvent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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, "SoQtRenderArea_sendSoEvent", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_sendSoEvent" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(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 '" "SoQtRenderArea_sendSoEvent" "', argument " "2"" of type '" "SoEvent const *""'"); 
  }
  arg2 = reinterpret_cast< SoEvent * >(argp2);
  result = (SbBool)(arg1)->sendSoEvent((SoEvent const *)arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_registerDevice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoQtDevice *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_registerDevice", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_registerDevice" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoQtDevice, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_registerDevice" "', argument " "2"" of type '" "SoQtDevice *""'"); 
  }
  arg2 = reinterpret_cast< SoQtDevice * >(argp2);
  (arg1)->registerDevice(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_unregisterDevice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtRenderArea *arg1 = 0 ;
  SoQtDevice *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtRenderArea_unregisterDevice", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_unregisterDevice" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoQtDevice, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtRenderArea_unregisterDevice" "', argument " "2"" of type '" "SoQtDevice *""'"); 
  }
  arg2 = reinterpret_cast< SoQtDevice * >(argp2);
  (arg1)->unregisterDevice(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setEventCallback__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setEventCallback" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(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];
  SoQtRenderArea_setEventCallback__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setEventCallback__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtRenderArea *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_SoQtRenderArea, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtRenderArea_setEventCallback" "', argument " "1"" of type '" "SoQtRenderArea *""'"); 
  }
  arg1 = reinterpret_cast< SoQtRenderArea * >(argp1);
  {
    if (!PyCallable_Check(swig_obj[1])) {
      PyErr_SetString(PyExc_TypeError, "need a callable object!");
      return NULL;
    }
    arg2 = swig_obj[1];
  }
  SoQtRenderArea_setEventCallback__SWIG_2(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtRenderArea_setEventCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtRenderArea_setEventCallback", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtRenderArea, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_QEvent__int);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtRenderArea_setEventCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtRenderArea, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_SoQtRenderArea_setEventCallback__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtRenderArea, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_QEvent__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_SoQtRenderArea_setEventCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtRenderArea, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PyCallable_Check(argv[1]) ? 1 : 0;
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SoQtRenderArea_setEventCallback__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtRenderArea_setEventCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtRenderArea::setEventCallback(SoQtRenderAreaEventCB *,void *)\n"
    "    SoQtRenderArea::setEventCallback(SoQtRenderAreaEventCB *)\n"
    "    SoQtRenderArea::setEventCallback(PyObject *,PyObject *)\n"
    "    SoQtRenderArea::setEventCallback(PyObject *)\n");
  return 0;
}


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

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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtViewer_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setCamera" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(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 '" "SoQtViewer_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_SoQtViewer_getCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_getCamera" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SoCamera *)((SoQtViewer const *)arg1)->getCamera();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoCamera, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setCameraType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setCameraType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setCameraType" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(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 '" "SoQtViewer_setCameraType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtViewer_setCameraType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setCameraType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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


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


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


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


SWIGINTERN PyObject *_wrap_SoQtViewer_setHeadlight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setHeadlight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setHeadlight" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setHeadlight" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setHeadlight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_isHeadlight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_isHeadlight" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SbBool)((SoQtViewer const *)arg1)->isHeadlight();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_getHeadlight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoDirectionalLight *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_getHeadlight" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SoDirectionalLight *)((SoQtViewer const *)arg1)->getHeadlight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoDirectionalLight, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setDrawStyle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewer::DrawType arg2 ;
  SoQtViewer::DrawStyle 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, "SoQtViewer_setDrawStyle", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setDrawStyle" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setDrawStyle" "', argument " "2"" of type '" "SoQtViewer::DrawType""'");
  } 
  arg2 = static_cast< SoQtViewer::DrawType >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoQtViewer_setDrawStyle" "', argument " "3"" of type '" "SoQtViewer::DrawStyle""'");
  } 
  arg3 = static_cast< SoQtViewer::DrawStyle >(val3);
  (arg1)->setDrawStyle(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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


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


SWIGINTERN PyObject *_wrap_SoQtViewer_setViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setViewing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setViewing" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setViewing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setViewing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_isViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_isViewing" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SbBool)((SoQtViewer const *)arg1)->isViewing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setCursorEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setCursorEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setCursorEnabled" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setCursorEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCursorEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_isCursorEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_isCursorEnabled" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SbBool)((SoQtViewer const *)arg1)->isCursorEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setAutoClipping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setAutoClipping", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setAutoClipping" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setAutoClipping" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setAutoClipping(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_isAutoClipping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_isAutoClipping" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SbBool)((SoQtViewer const *)arg1)->isAutoClipping();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setAutoClippingStrategy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewer::AutoClippingStrategy arg2 ;
  float arg3 ;
  SoQtAutoClippingCB *arg4 = 0 ;
  void *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int res5 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "2"" of type '" "SoQtViewer::AutoClippingStrategy""'");
  } 
  arg2 = static_cast< SoQtViewer::AutoClippingStrategy >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_r_q_const__SbVec2f__SbVec2f);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "4"" of type '" "SoQtAutoClippingCB *""'"); 
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&arg5), 0, 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "5"" of type '" "void *""'"); 
  }
  (arg1)->setAutoClippingStrategy(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setAutoClippingStrategy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewer::AutoClippingStrategy arg2 ;
  float arg3 ;
  SoQtAutoClippingCB *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "2"" of type '" "SoQtViewer::AutoClippingStrategy""'");
  } 
  arg2 = static_cast< SoQtViewer::AutoClippingStrategy >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_r_q_const__SbVec2f__SbVec2f);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "4"" of type '" "SoQtAutoClippingCB *""'"); 
    }
  }
  (arg1)->setAutoClippingStrategy(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setAutoClippingStrategy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewer::AutoClippingStrategy 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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "2"" of type '" "SoQtViewer::AutoClippingStrategy""'");
  } 
  arg2 = static_cast< SoQtViewer::AutoClippingStrategy >(val2);
  ecode3 = SWIG_AsVal_float(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setAutoClippingStrategy(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setAutoClippingStrategy__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewer::AutoClippingStrategy 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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setAutoClippingStrategy" "', argument " "2"" of type '" "SoQtViewer::AutoClippingStrategy""'");
  } 
  arg2 = static_cast< SoQtViewer::AutoClippingStrategy >(val2);
  (arg1)->setAutoClippingStrategy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setAutoClippingStrategy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtViewer_setAutoClippingStrategy", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoQtViewer_setAutoClippingStrategy__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 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_SoQtViewer_setAutoClippingStrategy__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_void_r_q_const__SbVec2f__SbVec2f);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SoQtViewer_setAutoClippingStrategy__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_void_r_q_const__SbVec2f__SbVec2f);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *ptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SoQtViewer_setAutoClippingStrategy__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtViewer_setAutoClippingStrategy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtViewer::setAutoClippingStrategy(SoQtViewer::AutoClippingStrategy const,float const,SoQtAutoClippingCB *,void *)\n"
    "    SoQtViewer::setAutoClippingStrategy(SoQtViewer::AutoClippingStrategy const,float const,SoQtAutoClippingCB *)\n"
    "    SoQtViewer::setAutoClippingStrategy(SoQtViewer::AutoClippingStrategy const,float const)\n"
    "    SoQtViewer::setAutoClippingStrategy(SoQtViewer::AutoClippingStrategy const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setStereoViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setStereoViewing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setStereoViewing" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setStereoViewing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setStereoViewing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_isStereoViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_isStereoViewing" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SbBool)((SoQtViewer const *)arg1)->isStereoViewing();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setStereoOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setStereoOffset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setStereoOffset" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_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_SoQtViewer_getStereoOffset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_getStereoOffset" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (float)((SoQtViewer const *)arg1)->getStereoOffset();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setStereoType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewer::StereoType 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, "SoQtViewer_setStereoType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setStereoType" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setStereoType" "', argument " "2"" of type '" "SoQtViewer::StereoType""'");
  } 
  arg2 = static_cast< SoQtViewer::StereoType >(val2);
  result = (SbBool)(arg1)->setStereoType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SoQtViewer_setAnaglyphStereoColorMasks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SbBool *arg2 = (SbBool *)0 ;
  SbBool *arg3 = (SbBool *)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, "SoQtViewer_setAnaglyphStereoColorMasks", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setAnaglyphStereoColorMasks" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(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 '" "SoQtViewer_setAnaglyphStereoColorMasks" "', argument " "2"" of type '" "SbBool const [3]""'"); 
  } 
  arg2 = reinterpret_cast< SbBool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQtViewer_setAnaglyphStereoColorMasks" "', argument " "3"" of type '" "SbBool const [3]""'"); 
  } 
  arg3 = reinterpret_cast< SbBool * >(argp3);
  (arg1)->setAnaglyphStereoColorMasks((SbBool const (*))arg2,(SbBool const (*))arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_getAnaglyphStereoColorMasks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SbBool *arg2 = (SbBool *)0 ;
  SbBool *arg3 = (SbBool *)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, "SoQtViewer_getAnaglyphStereoColorMasks", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_getAnaglyphStereoColorMasks" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(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 '" "SoQtViewer_getAnaglyphStereoColorMasks" "', argument " "2"" of type '" "SbBool [3]""'"); 
  } 
  arg2 = reinterpret_cast< SbBool * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SoQtViewer_getAnaglyphStereoColorMasks" "', argument " "3"" of type '" "SbBool [3]""'"); 
  } 
  arg3 = reinterpret_cast< SbBool * >(argp3);
  (arg1)->getAnaglyphStereoColorMasks(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setDetailSeek(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setDetailSeek", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setDetailSeek" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setDetailSeek" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDetailSeek(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_isDetailSeek(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_isDetailSeek" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SbBool)((SoQtViewer const *)arg1)->isDetailSeek();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setSeekTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setSeekTime", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setSeekTime" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_setSeekTime" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setSeekTime(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_getSeekTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_getSeekTime" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (float)((SoQtViewer const *)arg1)->getSeekTime();
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_addStartCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_addStartCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_addStartCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  {
    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_SoQtViewer_addStartCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_addStartCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_addStartCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  (arg1)->addStartCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_addStartCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtViewer_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_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtViewer_addStartCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoQtViewer_addStartCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtViewer_addStartCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtViewer::addStartCallback(SoQtViewerCB *,void *)\n"
    "    SoQtViewer::addStartCallback(SoQtViewerCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_addFinishCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_addFinishCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_addFinishCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  {
    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_SoQtViewer_addFinishCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_addFinishCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_addFinishCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  (arg1)->addFinishCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_addFinishCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtViewer_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_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtViewer_addFinishCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoQtViewer_addFinishCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtViewer_addFinishCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtViewer::addFinishCallback(SoQtViewerCB *,void *)\n"
    "    SoQtViewer::addFinishCallback(SoQtViewerCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_removeStartCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_removeStartCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_removeStartCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  {
    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_SoQtViewer_removeStartCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_removeStartCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_removeStartCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  (arg1)->removeStartCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_removeStartCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtViewer_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_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtViewer_removeStartCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoQtViewer_removeStartCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtViewer_removeStartCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtViewer::removeStartCallback(SoQtViewerCB *,void *)\n"
    "    SoQtViewer::removeStartCallback(SoQtViewerCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_removeFinishCallback__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_removeFinishCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_removeFinishCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  {
    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_SoQtViewer_removeFinishCallback__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtViewer *arg1 = 0 ;
  SoQtViewerCB *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_removeFinishCallback" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtViewer_removeFinishCallback" "', argument " "2"" of type '" "SoQtViewerCB *""'"); 
    }
  }
  (arg1)->removeFinishCallback(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_removeFinishCallback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtViewer_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_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtViewer_removeFinishCallback__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtViewer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_void_p_SoQtViewer__void);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = PyTuple_Check(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_SoQtViewer_removeFinishCallback__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtViewer_removeFinishCallback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtViewer::removeFinishCallback(SoQtViewerCB *,void *)\n"
    "    SoQtViewer::removeFinishCallback(SoQtViewerCB *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setWireframeOverlayColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setWireframeOverlayColor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setWireframeOverlayColor" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(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 '" "SoQtViewer_setWireframeOverlayColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtViewer_setWireframeOverlayColor" "', argument " "2"" of type '" "SbColor const &""'"); 
  }
  arg2 = reinterpret_cast< SbColor * >(argp2);
  (arg1)->setWireframeOverlayColor((SbColor const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_getWireframeOverlayColor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_getWireframeOverlayColor" "', argument " "1"" of type '" "SoQtViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SbColor *) &((SoQtViewer const *)arg1)->getWireframeOverlayColor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbColor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_setDoubleBuffer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setDoubleBuffer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setDoubleBuffer" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtViewer_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_SoQtViewer_setSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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, "SoQtViewer_setSceneGraph", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_setSceneGraph" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SoNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtViewer_setSceneGraph" "', argument " "2"" of type '" "SoNode *""'"); 
  }
  arg2 = reinterpret_cast< SoNode * >(argp2);
  (arg1)->setSceneGraph(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtViewer_getSceneGraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtViewer *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_SoQtViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtViewer_getSceneGraph" "', argument " "1"" of type '" "SoQtViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtViewer * >(argp1);
  result = (SoNode *)(arg1)->getSceneGraph();
  {
    resultobj = autocast_base(result);
  }
  return resultobj;
fail:
  return NULL;
}


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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtFullViewer_setDecoration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *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, "SoQtFullViewer_setDecoration", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_setDecoration" "', argument " "1"" of type '" "SoQtFullViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtFullViewer_setDecoration" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setDecoration(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_isDecoration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *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_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_isDecoration" "', argument " "1"" of type '" "SoQtFullViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  result = (SbBool)((SoQtFullViewer const *)arg1)->isDecoration();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_setPopupMenuEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *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, "SoQtFullViewer_setPopupMenuEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_setPopupMenuEnabled" "', argument " "1"" of type '" "SoQtFullViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtFullViewer_setPopupMenuEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setPopupMenuEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_isPopupMenuEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *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_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_isPopupMenuEnabled" "', argument " "1"" of type '" "SoQtFullViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  result = (SbBool)((SoQtFullViewer const *)arg1)->isPopupMenuEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_getAppPushButtonParent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_getAppPushButtonParent" "', argument " "1"" of type '" "SoQtFullViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  result = (QWidget *)((SoQtFullViewer const *)arg1)->getAppPushButtonParent();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_addAppPushButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtFullViewer_addAppPushButton", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_addAppPushButton" "', argument " "1"" of type '" "SoQtFullViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  (arg1)->addAppPushButton(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_insertAppPushButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *arg1 = 0 ;
  QWidget *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, "SoQtFullViewer_insertAppPushButton", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_insertAppPushButton" "', argument " "1"" of type '" "SoQtFullViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoQtFullViewer_insertAppPushButton" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->insertAppPushButton(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_removeAppPushButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtFullViewer_removeAppPushButton", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_removeAppPushButton" "', argument " "1"" of type '" "SoQtFullViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  (arg1)->removeAppPushButton(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_findAppPushButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtFullViewer_findAppPushButton", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_findAppPushButton" "', argument " "1"" of type '" "SoQtFullViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = (int)((SoQtFullViewer const *)arg1)->findAppPushButton(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_lengthAppPushButton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *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_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_lengthAppPushButton" "', argument " "1"" of type '" "SoQtFullViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  result = (int)((SoQtFullViewer const *)arg1)->lengthAppPushButton();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_getRenderAreaWidget(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  QWidget *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_getRenderAreaWidget" "', argument " "1"" of type '" "SoQtFullViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  result = (QWidget *)((SoQtFullViewer const *)arg1)->getRenderAreaWidget();
  {
    resultobj = NULL;
    {
      PyObject *qt = NULL;
      
      /* try to create a PySide QWidget instance through shiboken */
      
      PyObject *shiboken = getShiboken();
      
      if (shiboken && PyModule_Check(shiboken)) {
        /* check if the qt module is available and import it */
        if (!(qt = PyDict_GetItemString(PyModule_GetDict(PyImport_AddModule("__main__")), PYSIDE_QT))) {
          qt = PyImport_ImportModule(PYSIDE_QT);
        }
        
        if (qt && PyModule_Check(qt)) {
          /* grab the wrapInstance(addr, type) function */
          PyObject *shiboken_wrapinst_func = NULL;
          shiboken_wrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "wrapInstance");
          
          if (PyCallable_Check(shiboken_wrapinst_func)) {
            PyObject *qwidget_type = NULL, *arglist = NULL;
            qwidget_type = PyDict_GetItemString(PyModule_GetDict(qt), "QWidget");
            
            arglist = Py_BuildValue("(nO)", result, qwidget_type);
            
            if (!(resultobj = PyObject_CallObject(shiboken_wrapinst_func, arglist))) {
              PyErr_Print();
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      /* if no QWidget could be created through shiboken return a swig QWidget type */
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !resultobj) {
        PyErr_Clear();
        resultobj = SWIG_NewPointerObj((void *)(result), SWIGTYPE_p_QWidget, 0);
      }
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFullViewer_setViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFullViewer *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, "SoQtFullViewer_setViewing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFullViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFullViewer_setViewing" "', argument " "1"" of type '" "SoQtFullViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFullViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtFullViewer_setViewing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setViewing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtPlaneViewer_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPlaneViewer_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoQtPlaneViewer::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoQtPlaneViewer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  SbBool arg3 ;
  SoQtFullViewer::BuildFlag arg4 ;
  SoQtViewer::Type arg5 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SoQtPlaneViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtPlaneViewer" "', argument " "2"" of type '" "char const *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 '" "new_SoQtPlaneViewer" "', 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 '" "new_SoQtPlaneViewer" "', argument " "4"" of type '" "SoQtFullViewer::BuildFlag""'");
  } 
  arg4 = static_cast< SoQtFullViewer::BuildFlag >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SoQtPlaneViewer" "', argument " "5"" of type '" "SoQtViewer::Type""'");
  } 
  arg5 = static_cast< SoQtViewer::Type >(val5);
  result = (SoQtPlaneViewer *)new SoQtPlaneViewer(arg1,(char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtPlaneViewer, 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_SoQtPlaneViewer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  SbBool arg3 ;
  SoQtFullViewer::BuildFlag arg4 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SoQtPlaneViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtPlaneViewer" "', argument " "2"" of type '" "char const *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 '" "new_SoQtPlaneViewer" "', 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 '" "new_SoQtPlaneViewer" "', argument " "4"" of type '" "SoQtFullViewer::BuildFlag""'");
  } 
  arg4 = static_cast< SoQtFullViewer::BuildFlag >(val4);
  result = (SoQtPlaneViewer *)new SoQtPlaneViewer(arg1,(char const *)arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtPlaneViewer, 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_SoQtPlaneViewer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  SbBool arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoQtPlaneViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtPlaneViewer" "', argument " "2"" of type '" "char const *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 '" "new_SoQtPlaneViewer" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoQtPlaneViewer *)new SoQtPlaneViewer(arg1,(char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtPlaneViewer, 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_SoQtPlaneViewer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SoQtPlaneViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtPlaneViewer" "', argument " "2"" of type '" "char const *const""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SoQtPlaneViewer *)new SoQtPlaneViewer(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtPlaneViewer, 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_SoQtPlaneViewer__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  SoQtPlaneViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = (SoQtPlaneViewer *)new SoQtPlaneViewer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtPlaneViewer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_SoQtPlaneViewer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoQtPlaneViewer", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoQtPlaneViewer__SWIG_5(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      return _wrap_new_SoQtPlaneViewer__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SoQtPlaneViewer__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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_new_SoQtPlaneViewer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SoQtPlaneViewer__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            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_new_SoQtPlaneViewer__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoQtPlaneViewer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtPlaneViewer::SoQtPlaneViewer(QWidget *,char const *const,SbBool,SoQtFullViewer::BuildFlag,SoQtViewer::Type)\n"
    "    SoQtPlaneViewer::SoQtPlaneViewer(QWidget *,char const *const,SbBool,SoQtFullViewer::BuildFlag)\n"
    "    SoQtPlaneViewer::SoQtPlaneViewer(QWidget *,char const *const,SbBool)\n"
    "    SoQtPlaneViewer::SoQtPlaneViewer(QWidget *,char const *const)\n"
    "    SoQtPlaneViewer::SoQtPlaneViewer(QWidget *)\n"
    "    SoQtPlaneViewer::SoQtPlaneViewer()\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_SoQtPlaneViewer_setViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPlaneViewer *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, "SoQtPlaneViewer_setViewing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPlaneViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPlaneViewer_setViewing" "', argument " "1"" of type '" "SoQtPlaneViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPlaneViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPlaneViewer_setViewing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setViewing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPlaneViewer_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPlaneViewer *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, "SoQtPlaneViewer_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPlaneViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPlaneViewer_setCamera" "', argument " "1"" of type '" "SoQtPlaneViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPlaneViewer * >(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 '" "SoQtPlaneViewer_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_SoQtPlaneViewer_setCursorEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPlaneViewer *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, "SoQtPlaneViewer_setCursorEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPlaneViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPlaneViewer_setCursorEnabled" "', argument " "1"" of type '" "SoQtPlaneViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPlaneViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPlaneViewer_setCursorEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCursorEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtExaminerViewer_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoQtExaminerViewer::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoQtExaminerViewer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  SoQtFullViewer::BuildFlag arg4 ;
  SoQtViewer::Type arg5 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SoQtExaminerViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtExaminerViewer" "', 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 '" "new_SoQtExaminerViewer" "', 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 '" "new_SoQtExaminerViewer" "', argument " "4"" of type '" "SoQtFullViewer::BuildFlag""'");
  } 
  arg4 = static_cast< SoQtFullViewer::BuildFlag >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SoQtExaminerViewer" "', argument " "5"" of type '" "SoQtViewer::Type""'");
  } 
  arg5 = static_cast< SoQtViewer::Type >(val5);
  result = (SoQtExaminerViewer *)new SoQtExaminerViewer(arg1,(char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtExaminerViewer, 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_SoQtExaminerViewer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  SoQtFullViewer::BuildFlag arg4 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SoQtExaminerViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtExaminerViewer" "', 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 '" "new_SoQtExaminerViewer" "', 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 '" "new_SoQtExaminerViewer" "', argument " "4"" of type '" "SoQtFullViewer::BuildFlag""'");
  } 
  arg4 = static_cast< SoQtFullViewer::BuildFlag >(val4);
  result = (SoQtExaminerViewer *)new SoQtExaminerViewer(arg1,(char const *)arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtExaminerViewer, 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_SoQtExaminerViewer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoQtExaminerViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtExaminerViewer" "', 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 '" "new_SoQtExaminerViewer" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoQtExaminerViewer *)new SoQtExaminerViewer(arg1,(char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtExaminerViewer, 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_SoQtExaminerViewer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SoQtExaminerViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtExaminerViewer" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SoQtExaminerViewer *)new SoQtExaminerViewer(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtExaminerViewer, 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_SoQtExaminerViewer__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  SoQtExaminerViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = (SoQtExaminerViewer *)new SoQtExaminerViewer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtExaminerViewer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_SoQtExaminerViewer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoQtExaminerViewer", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoQtExaminerViewer__SWIG_5(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      return _wrap_new_SoQtExaminerViewer__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SoQtExaminerViewer__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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_new_SoQtExaminerViewer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SoQtExaminerViewer__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            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_new_SoQtExaminerViewer__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoQtExaminerViewer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtExaminerViewer::SoQtExaminerViewer(QWidget *,char const *,SbBool,SoQtFullViewer::BuildFlag,SoQtViewer::Type)\n"
    "    SoQtExaminerViewer::SoQtExaminerViewer(QWidget *,char const *,SbBool,SoQtFullViewer::BuildFlag)\n"
    "    SoQtExaminerViewer::SoQtExaminerViewer(QWidget *,char const *,SbBool)\n"
    "    SoQtExaminerViewer::SoQtExaminerViewer(QWidget *,char const *)\n"
    "    SoQtExaminerViewer::SoQtExaminerViewer(QWidget *)\n"
    "    SoQtExaminerViewer::SoQtExaminerViewer()\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_setAnimationEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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, "SoQtExaminerViewer_setAnimationEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_setAnimationEnabled" "', argument " "1"" of type '" "SoQtExaminerViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtExaminerViewer_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 *_wrap_SoQtExaminerViewer_isAnimationEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_isAnimationEnabled" "', argument " "1"" of type '" "SoQtExaminerViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  result = (SbBool)((SoQtExaminerViewer const *)arg1)->isAnimationEnabled();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_isAnimating(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_isAnimating" "', argument " "1"" of type '" "SoQtExaminerViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  result = (SbBool)((SoQtExaminerViewer const *)arg1)->isAnimating();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_setFeedbackVisibility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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, "SoQtExaminerViewer_setFeedbackVisibility", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_setFeedbackVisibility" "', argument " "1"" of type '" "SoQtExaminerViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtExaminerViewer_setFeedbackVisibility" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setFeedbackVisibility(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_isFeedbackVisible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_isFeedbackVisible" "', argument " "1"" of type '" "SoQtExaminerViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  result = (SbBool)((SoQtExaminerViewer const *)arg1)->isFeedbackVisible();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_setFeedbackSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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, "SoQtExaminerViewer_setFeedbackSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_setFeedbackSize" "', argument " "1"" of type '" "SoQtExaminerViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtExaminerViewer_setFeedbackSize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setFeedbackSize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_getFeedbackSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_getFeedbackSize" "', argument " "1"" of type '" "SoQtExaminerViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  result = (int)((SoQtExaminerViewer const *)arg1)->getFeedbackSize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_setViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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, "SoQtExaminerViewer_setViewing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_setViewing" "', argument " "1"" of type '" "SoQtExaminerViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtExaminerViewer_setViewing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setViewing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtExaminerViewer_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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, "SoQtExaminerViewer_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_setCamera" "', argument " "1"" of type '" "SoQtExaminerViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(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 '" "SoQtExaminerViewer_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_SoQtExaminerViewer_setCursorEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtExaminerViewer *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, "SoQtExaminerViewer_setCursorEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtExaminerViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtExaminerViewer_setCursorEnabled" "', argument " "1"" of type '" "SoQtExaminerViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtExaminerViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtExaminerViewer_setCursorEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCursorEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtConstrainedViewer_setUpDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtConstrainedViewer *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, "SoQtConstrainedViewer_setUpDirection", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtConstrainedViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtConstrainedViewer_setUpDirection" "', argument " "1"" of type '" "SoQtConstrainedViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtConstrainedViewer * >(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 '" "SoQtConstrainedViewer_setUpDirection" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtConstrainedViewer_setUpDirection" "', argument " "2"" of type '" "SbVec3f const &""'"); 
  }
  arg2 = reinterpret_cast< SbVec3f * >(argp2);
  (arg1)->setUpDirection((SbVec3f const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtConstrainedViewer_getUpDirection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtConstrainedViewer *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_SoQtConstrainedViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtConstrainedViewer_getUpDirection" "', argument " "1"" of type '" "SoQtConstrainedViewer const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtConstrainedViewer * >(argp1);
  result = (SbVec3f *) &((SoQtConstrainedViewer const *)arg1)->getUpDirection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SbVec3f, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtConstrainedViewer_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtConstrainedViewer *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, "SoQtConstrainedViewer_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtConstrainedViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtConstrainedViewer_setCamera" "', argument " "1"" of type '" "SoQtConstrainedViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtConstrainedViewer * >(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 '" "SoQtConstrainedViewer_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_SoQtConstrainedViewer_saveHomePosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtConstrainedViewer *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtConstrainedViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtConstrainedViewer_saveHomePosition" "', argument " "1"" of type '" "SoQtConstrainedViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtConstrainedViewer * >(argp1);
  (arg1)->saveHomePosition();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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

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


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


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


SWIGINTERN PyObject *_wrap_SoQtFlyViewer_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  void *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtFlyViewer_createInstance", 0, 0, 0)) SWIG_fail;
  result = (void *)SoQtFlyViewer::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SoQtFlyViewer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  SoQtFullViewer::BuildFlag arg4 ;
  SoQtViewer::Type arg5 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SoQtFlyViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtFlyViewer" "', 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 '" "new_SoQtFlyViewer" "', 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 '" "new_SoQtFlyViewer" "', argument " "4"" of type '" "SoQtFullViewer::BuildFlag""'");
  } 
  arg4 = static_cast< SoQtFullViewer::BuildFlag >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SoQtFlyViewer" "', argument " "5"" of type '" "SoQtViewer::Type""'");
  } 
  arg5 = static_cast< SoQtViewer::Type >(val5);
  result = (SoQtFlyViewer *)new SoQtFlyViewer(arg1,(char const *)arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtFlyViewer, 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_SoQtFlyViewer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  SoQtFullViewer::BuildFlag arg4 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SoQtFlyViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtFlyViewer" "', 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 '" "new_SoQtFlyViewer" "', 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 '" "new_SoQtFlyViewer" "', argument " "4"" of type '" "SoQtFullViewer::BuildFlag""'");
  } 
  arg4 = static_cast< SoQtFullViewer::BuildFlag >(val4);
  result = (SoQtFlyViewer *)new SoQtFlyViewer(arg1,(char const *)arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtFlyViewer, 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_SoQtFlyViewer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  SbBool arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SoQtFlyViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtFlyViewer" "', 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 '" "new_SoQtFlyViewer" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  result = (SoQtFlyViewer *)new SoQtFlyViewer(arg1,(char const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtFlyViewer, 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_SoQtFlyViewer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  char *arg2 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  SoQtFlyViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoQtFlyViewer" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (SoQtFlyViewer *)new SoQtFlyViewer(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtFlyViewer, 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_SoQtFlyViewer__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QWidget *arg1 = 0 ;
  SoQtFlyViewer *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    {
      if (swig_obj[0] == Py_None) {
        arg1 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg1 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg1) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[0], (void **)(&arg1), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  result = (SoQtFlyViewer *)new SoQtFlyViewer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtFlyViewer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_new_SoQtFlyViewer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoQtFlyViewer", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoQtFlyViewer__SWIG_5(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      return _wrap_new_SoQtFlyViewer__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SoQtFlyViewer__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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_new_SoQtFlyViewer__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SoQtFlyViewer__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      void *ptr = NULL;
      {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", argv[0]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              ptr = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      _v = 1;
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !ptr) {
        _v = 0;
        PyErr_Clear();
        if ((SWIG_ConvertPtr(argv[0], (void **)(&ptr), SWIGTYPE_p_QWidget, 0)) != -1) {
          _v = 1;
        }
      }
    }
    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) {
          {
            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_new_SoQtFlyViewer__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoQtFlyViewer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtFlyViewer::SoQtFlyViewer(QWidget *,char const *,SbBool,SoQtFullViewer::BuildFlag,SoQtViewer::Type)\n"
    "    SoQtFlyViewer::SoQtFlyViewer(QWidget *,char const *,SbBool,SoQtFullViewer::BuildFlag)\n"
    "    SoQtFlyViewer::SoQtFlyViewer(QWidget *,char const *,SbBool)\n"
    "    SoQtFlyViewer::SoQtFlyViewer(QWidget *,char const *)\n"
    "    SoQtFlyViewer::SoQtFlyViewer(QWidget *)\n"
    "    SoQtFlyViewer::SoQtFlyViewer()\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_SoQtFlyViewer_setViewing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFlyViewer *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, "SoQtFlyViewer_setViewing", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFlyViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFlyViewer_setViewing" "', argument " "1"" of type '" "SoQtFlyViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFlyViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtFlyViewer_setViewing" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setViewing(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_SoQtFlyViewer_setCamera(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFlyViewer *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, "SoQtFlyViewer_setCamera", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFlyViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFlyViewer_setCamera" "', argument " "1"" of type '" "SoQtFlyViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFlyViewer * >(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 '" "SoQtFlyViewer_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_SoQtFlyViewer_setCursorEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFlyViewer *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, "SoQtFlyViewer_setCursorEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFlyViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFlyViewer_setCursorEnabled" "', argument " "1"" of type '" "SoQtFlyViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFlyViewer * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtFlyViewer_setCursorEnabled" "', argument " "2"" of type '" "SbBool""'");
  } 
  arg2 = static_cast< SbBool >(val2);
  (arg1)->setCursorEnabled(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtFlyViewer_setCameraType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtFlyViewer *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, "SoQtFlyViewer_setCameraType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtFlyViewer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtFlyViewer_setCameraType" "', argument " "1"" of type '" "SoQtFlyViewer *""'"); 
  }
  arg1 = reinterpret_cast< SoQtFlyViewer * >(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 '" "SoQtFlyViewer_setCameraType" "', argument " "2"" of type '" "SoType""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SoQtFlyViewer_setCameraType" "', argument " "2"" of type '" "SoType""'");
    } else {
      SoType * temp = reinterpret_cast< SoType * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setCameraType(SWIG_STD_MOVE(arg2));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_SoQtPopupMenu_createInstance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_createInstance", 0, 0, 0)) SWIG_fail;
  result = (SoQtPopupMenu *)SoQtPopupMenu::createInstance();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_newMenu__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_newMenu" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtPopupMenu_newMenu" "', 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 '" "SoQtPopupMenu_newMenu" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->newMenu((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_SoQtPopupMenu_newMenu__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_newMenu" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtPopupMenu_newMenu" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->newMenu((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_SoQtPopupMenu_newMenu(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_newMenu", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtPopupMenu_newMenu__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 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_SoQtPopupMenu_newMenu__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtPopupMenu_newMenu'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtPopupMenu::newMenu(char const *,int)\n"
    "    SoQtPopupMenu::newMenu(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getMenu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_getMenu", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getMenu" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtPopupMenu_getMenu" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->getMenu((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_SoQtPopupMenu_setMenuTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  int arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_setMenuTitle", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_setMenuTitle" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_setMenuTitle" "', 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 '" "SoQtPopupMenu_setMenuTitle" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->setMenuTitle(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getMenuTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_getMenuTitle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getMenuTitle" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_getMenuTitle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)(arg1)->getMenuTitle(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_newMenuItem__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_newMenuItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtPopupMenu_newMenuItem" "', 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 '" "SoQtPopupMenu_newMenuItem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->newMenuItem((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_SoQtPopupMenu_newMenuItem__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_newMenuItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtPopupMenu_newMenuItem" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->newMenuItem((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_SoQtPopupMenu_newMenuItem(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_newMenuItem", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SoQtPopupMenu_newMenuItem__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 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_SoQtPopupMenu_newMenuItem__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtPopupMenu_newMenuItem'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtPopupMenu::newMenuItem(char const *,int)\n"
    "    SoQtPopupMenu::newMenuItem(char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getMenuItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_getMenuItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getMenuItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SoQtPopupMenu_getMenuItem" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (int)(arg1)->getMenuItem((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_SoQtPopupMenu_setMenuItemTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  int arg2 ;
  char *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_setMenuItemTitle", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_setMenuItemTitle" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_setMenuItemTitle" "', 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 '" "SoQtPopupMenu_setMenuItemTitle" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  (arg1)->setMenuItemTitle(arg2,(char const *)arg3);
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getMenuItemTitle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_getMenuItemTitle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getMenuItemTitle" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_getMenuItemTitle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (char *)(arg1)->getMenuItemTitle(arg2);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_setMenuItemEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_setMenuItemEnabled", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_setMenuItemEnabled" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_setMenuItemEnabled" "', 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 '" "SoQtPopupMenu_setMenuItemEnabled" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setMenuItemEnabled(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getMenuItemEnabled(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_getMenuItemEnabled", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getMenuItemEnabled" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_getMenuItemEnabled" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)(arg1)->getMenuItemEnabled(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_setMenuItemMarked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_setMenuItemMarked", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_setMenuItemMarked" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_setMenuItemMarked" "', 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 '" "SoQtPopupMenu_setMenuItemMarked" "', argument " "3"" of type '" "SbBool""'");
  } 
  arg3 = static_cast< SbBool >(val3);
  (arg1)->setMenuItemMarked(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getMenuItemMarked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_getMenuItemMarked", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getMenuItemMarked" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_getMenuItemMarked" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (SbBool)(arg1)->getMenuItemMarked(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addMenu__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int 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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addMenu" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_addMenu" "', 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 '" "SoQtPopupMenu_addMenu" "', 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 '" "SoQtPopupMenu_addMenu" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->addMenu(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addMenu__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addMenu" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_addMenu" "', 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 '" "SoQtPopupMenu_addMenu" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addMenu(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addMenu(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_addMenu", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 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_SoQtPopupMenu_addMenu__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 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_SoQtPopupMenu_addMenu__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtPopupMenu_addMenu'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtPopupMenu::addMenu(int,int,int)\n"
    "    SoQtPopupMenu::addMenu(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addMenuItem__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int 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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addMenuItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_addMenuItem" "', 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 '" "SoQtPopupMenu_addMenuItem" "', 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 '" "SoQtPopupMenu_addMenuItem" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->addMenuItem(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addMenuItem__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addMenuItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_addMenuItem" "', 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 '" "SoQtPopupMenu_addMenuItem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addMenuItem(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addMenuItem(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_addMenuItem", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 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_SoQtPopupMenu_addMenuItem__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 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_SoQtPopupMenu_addMenuItem__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtPopupMenu_addMenuItem'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtPopupMenu::addMenuItem(int,int,int)\n"
    "    SoQtPopupMenu::addMenuItem(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addSeparator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addSeparator" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_addSeparator" "', 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 '" "SoQtPopupMenu_addSeparator" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addSeparator(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addSeparator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addSeparator" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_addSeparator" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addSeparator(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addSeparator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_addSeparator", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SoQtPopupMenu_addSeparator__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtPopupMenu, 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_SoQtPopupMenu_addSeparator__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SoQtPopupMenu_addSeparator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtPopupMenu::addSeparator(int,int)\n"
    "    SoQtPopupMenu::addSeparator(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_removeMenu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_removeMenu", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_removeMenu" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_removeMenu" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeMenu(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_removeMenuItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_removeMenuItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_removeMenuItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_removeMenuItem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeMenuItem(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_popUp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  QWidget *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_popUp", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_popUp" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  {
    {
      if (swig_obj[1] == Py_None) {
        arg2 = NULL;
      } else {
        PyObject *shiboken = getShiboken();
        
        if (shiboken && PyModule_Check(shiboken)) {
          /* grab the unwrapInstance(obj) function */
          PyObject *shiboken_unwrapinst_func = NULL;
          shiboken_unwrapinst_func = PyDict_GetItemString(PyModule_GetDict(shiboken), "getCppPointer");
          
          if (PyCallable_Check(shiboken_unwrapinst_func)) {
            PyObject *arglist = NULL, *address = NULL;
            arglist = Py_BuildValue("(O)", swig_obj[1]);
            if (!(address = PyObject_CallObject(shiboken_unwrapinst_func, arglist))) {
              PyErr_Print();
            } else if (PyNumber_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(address);
            } else if (PyTuple_Check(address)) {
              arg2 = (QWidget*)PyLong_AsVoidPtr(PyTuple_GetItem(address, 0));
            }
            
            Py_DECREF(arglist);
          }
        }
      }
      
      if (PyErr_ExceptionMatches(PyExc_ImportError) || !arg2) {
        PyErr_Clear();
        if ((SWIG_ConvertPtr(swig_obj[1], (void **)(&arg2), SWIGTYPE_p_QWidget, SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
      }
    }  
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SoQtPopupMenu_popUp" "', 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 '" "SoQtPopupMenu_popUp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->popUp(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_newRadioGroup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_newRadioGroup" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_newRadioGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->newRadioGroup(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_newRadioGroup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_newRadioGroup" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  result = (int)(arg1)->newRadioGroup();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getRadioGroup(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_getRadioGroup", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getRadioGroup" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_getRadioGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->getRadioGroup(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getRadioGroupSize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_getRadioGroupSize", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getRadioGroupSize" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_getRadioGroupSize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->getRadioGroupSize(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addRadioGroupItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_addRadioGroupItem", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addRadioGroupItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_addRadioGroupItem" "', 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 '" "SoQtPopupMenu_addRadioGroupItem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addRadioGroupItem(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_removeRadioGroupItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_removeRadioGroupItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_removeRadioGroupItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_removeRadioGroupItem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeRadioGroupItem(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_setRadioGroupMarkedItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_setRadioGroupMarkedItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_setRadioGroupMarkedItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_setRadioGroupMarkedItem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setRadioGroupMarkedItem(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_getRadioGroupMarkedItem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *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, "SoQtPopupMenu_getRadioGroupMarkedItem", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_getRadioGroupMarkedItem" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SoQtPopupMenu_getRadioGroupMarkedItem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->getRadioGroupMarkedItem(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_addMenuSelectionCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  SoQtMenuSelectionCallback *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_addMenuSelectionCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_addMenuSelectionCallback" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtPopupMenu_addMenuSelectionCallback" "', argument " "2"" of type '" "SoQtMenuSelectionCallback *""'"); 
    }
  }
  {
    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)->addMenuSelectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtPopupMenu_removeMenuSelectionCallback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtPopupMenu *arg1 = 0 ;
  SoQtMenuSelectionCallback *arg2 = 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtPopupMenu_removeMenuSelectionCallback", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtPopupMenu, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtPopupMenu_removeMenuSelectionCallback" "', argument " "1"" of type '" "SoQtPopupMenu *""'"); 
  }
  arg1 = reinterpret_cast< SoQtPopupMenu * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_int_p_void__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SoQtPopupMenu_removeMenuSelectionCallback" "', argument " "2"" of type '" "SoQtMenuSelectionCallback *""'"); 
    }
  }
  {
    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)->removeMenuSelectionCallback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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


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


SWIGINTERN PyObject *_wrap_new_SoQtCursor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SoQtCursor::Shape arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SoQtCursor *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_SoQtCursor" "', argument " "1"" of type '" "SoQtCursor::Shape""'");
  } 
  arg1 = static_cast< SoQtCursor::Shape >(val1);
  result = (SoQtCursor *)new SoQtCursor(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtCursor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_new_SoQtCursor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SoQtCursor", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SoQtCursor__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SoQtCursor__CustomCursor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoQtCursor__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SoQtCursor, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SoQtCursor__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_SoQtCursor__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SoQtCursor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SoQtCursor::SoQtCursor()\n"
    "    SoQtCursor::SoQtCursor(SoQtCursor::Shape const)\n"
    "    SoQtCursor::SoQtCursor(SoQtCursor::CustomCursor const *)\n"
    "    SoQtCursor::SoQtCursor(SoQtCursor const &)\n");
  return 0;
}


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


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


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


SWIGINTERN PyObject *_wrap_SoQtCursor_getCustomCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtCursor *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SoQtCursor::CustomCursor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SoQtCursor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SoQtCursor_getCustomCursor" "', argument " "1"" of type '" "SoQtCursor const *""'"); 
  }
  arg1 = reinterpret_cast< SoQtCursor * >(argp1);
  result = (SoQtCursor::CustomCursor *) &((SoQtCursor const *)arg1)->getCustomCursor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtCursor__CustomCursor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtCursor_getZoomCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtCursor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtCursor_getZoomCursor", 0, 0, 0)) SWIG_fail;
  result = (SoQtCursor *) &SoQtCursor::getZoomCursor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtCursor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtCursor_getPanCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtCursor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtCursor_getPanCursor", 0, 0, 0)) SWIG_fail;
  result = (SoQtCursor *) &SoQtCursor::getPanCursor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtCursor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtCursor_getRotateCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtCursor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtCursor_getRotateCursor", 0, 0, 0)) SWIG_fail;
  result = (SoQtCursor *) &SoQtCursor::getRotateCursor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtCursor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SoQtCursor_getBlankCursor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoQtCursor *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SoQtCursor_getBlankCursor", 0, 0, 0)) SWIG_fail;
  result = (SoQtCursor *) &SoQtCursor::getBlankCursor();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SoQtCursor, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *SoQtCursor_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, NULL},
	 { "delete_charp", _wrap_delete_charp, METH_O, NULL},
	 { "charp_assign", _wrap_charp_assign, METH_VARARGS, NULL},
	 { "charp_value", _wrap_charp_value, METH_O, NULL},
	 { "charp_cast", _wrap_charp_cast, METH_O, NULL},
	 { "charp_frompointer", _wrap_charp_frompointer, METH_O, NULL},
	 { "charp_swigregister", charp_swigregister, METH_O, NULL},
	 { "charp_swiginit", charp_swiginit, METH_VARARGS, NULL},
	 { "new_intp", _wrap_new_intp, METH_NOARGS, NULL},
	 { "delete_intp", _wrap_delete_intp, METH_O, NULL},
	 { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL},
	 { "intp_value", _wrap_intp_value, METH_O, NULL},
	 { "intp_cast", _wrap_intp_cast, METH_O, NULL},
	 { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL},
	 { "intp_swigregister", intp_swigregister, METH_O, NULL},
	 { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL},
	 { "new_longp", _wrap_new_longp, METH_NOARGS, NULL},
	 { "delete_longp", _wrap_delete_longp, METH_O, NULL},
	 { "longp_assign", _wrap_longp_assign, METH_VARARGS, NULL},
	 { "longp_value", _wrap_longp_value, METH_O, NULL},
	 { "longp_cast", _wrap_longp_cast, METH_O, NULL},
	 { "longp_frompointer", _wrap_longp_frompointer, METH_O, NULL},
	 { "longp_swigregister", longp_swigregister, METH_O, NULL},
	 { "longp_swiginit", longp_swiginit, METH_VARARGS, NULL},
	 { "new_floatp", _wrap_new_floatp, METH_NOARGS, NULL},
	 { "delete_floatp", _wrap_delete_floatp, METH_O, NULL},
	 { "floatp_assign", _wrap_floatp_assign, METH_VARARGS, NULL},
	 { "floatp_value", _wrap_floatp_value, METH_O, NULL},
	 { "floatp_cast", _wrap_floatp_cast, METH_O, NULL},
	 { "floatp_frompointer", _wrap_floatp_frompointer, METH_O, NULL},
	 { "floatp_swigregister", floatp_swigregister, METH_O, NULL},
	 { "floatp_swiginit", floatp_swiginit, METH_VARARGS, NULL},
	 { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL},
	 { "delete_doublep", _wrap_delete_doublep, METH_O, NULL},
	 { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL},
	 { "doublep_value", _wrap_doublep_value, METH_O, NULL},
	 { "doublep_cast", _wrap_doublep_cast, METH_O, NULL},
	 { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL},
	 { "doublep_swigregister", doublep_swigregister, METH_O, NULL},
	 { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL},
	 { "new_SbDict", _wrap_new_SbDict, METH_VARARGS, NULL},
	 { "delete_SbDict", _wrap_delete_SbDict, METH_O, NULL},
	 { "SbDict_applyToAll", _wrap_SbDict_applyToAll, METH_VARARGS, NULL},
	 { "SbDict_clear", _wrap_SbDict_clear, METH_O, NULL},
	 { "SbDict_enter", _wrap_SbDict_enter, METH_VARARGS, NULL},
	 { "SbDict_find", _wrap_SbDict_find, METH_VARARGS, NULL},
	 { "SbDict_makePList", _wrap_SbDict_makePList, METH_VARARGS, NULL},
	 { "SbDict_remove", _wrap_SbDict_remove, METH_VARARGS, NULL},
	 { "SbDict_setHashingFunction", _wrap_SbDict_setHashingFunction, METH_VARARGS, NULL},
	 { "SbDict_swigregister", SbDict_swigregister, METH_O, NULL},
	 { "SbDict_swiginit", SbDict_swiginit, METH_VARARGS, NULL},
	 { "SoType_fromName", _wrap_SoType_fromName, METH_O, NULL},
	 { "SoType_getName", _wrap_SoType_getName, METH_O, NULL},
	 { "SoType_getParent", _wrap_SoType_getParent, METH_O, NULL},
	 { "SoType_isDerivedFrom", _wrap_SoType_isDerivedFrom, METH_VARARGS, NULL},
	 { "SoType_getAllDerivedFrom", _wrap_SoType_getAllDerivedFrom, METH_VARARGS, NULL},
	 { "SoType_canCreateInstance", _wrap_SoType_canCreateInstance, METH_O, NULL},
	 { "SoType_getData", _wrap_SoType_getData, METH_O, NULL},
	 { "SoType_getKey", _wrap_SoType_getKey, METH_O, NULL},
	 { "SoType___eq__", _wrap_SoType___eq__, METH_VARARGS, NULL},
	 { "SoType___ne__", _wrap_SoType___ne__, METH_VARARGS, NULL},
	 { "SoType___lt__", _wrap_SoType___lt__, METH_VARARGS, NULL},
	 { "SoType___le__", _wrap_SoType___le__, METH_VARARGS, NULL},
	 { "SoType___ge__", _wrap_SoType___ge__, METH_VARARGS, NULL},
	 { "SoType___gt__", _wrap_SoType___gt__, METH_VARARGS, NULL},
	 { "SoType_removeType", _wrap_SoType_removeType, METH_O, NULL},
	 { "SoType_init", _wrap_SoType_init, METH_NOARGS, NULL},
	 { "SoType_fromKey", _wrap_SoType_fromKey, METH_O, NULL},
	 { "SoType_badType", _wrap_SoType_badType, METH_NOARGS, NULL},
	 { "SoType_isBad", _wrap_SoType_isBad, METH_O, NULL},
	 { "SoType_makeInternal", _wrap_SoType_makeInternal, METH_O, NULL},
	 { "SoType_isInternal", _wrap_SoType_isInternal, METH_O, NULL},
	 { "SoType_getNumTypes", _wrap_SoType_getNumTypes, METH_NOARGS, NULL},
	 { "SoType_getInstantiationMethod", _wrap_SoType_getInstantiationMethod, METH_O, NULL},
	 { "SoType_createInstance", _wrap_SoType_createInstance, METH_O, NULL},
	 { "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, NULL},
	 { "delete_SbPList", _wrap_delete_SbPList, METH_O, NULL},
	 { "SbPList_copy", _wrap_SbPList_copy, METH_VARARGS, NULL},
	 { "SbPList_fit", _wrap_SbPList_fit, METH_O, NULL},
	 { "SbPList_append", _wrap_SbPList_append, METH_VARARGS, NULL},
	 { "SbPList_find", _wrap_SbPList_find, METH_VARARGS, NULL},
	 { "SbPList_insert", _wrap_SbPList_insert, METH_VARARGS, NULL},
	 { "SbPList_removeItem", _wrap_SbPList_removeItem, METH_VARARGS, NULL},
	 { "SbPList_remove", _wrap_SbPList_remove, METH_VARARGS, NULL},
	 { "SbPList_removeFast", _wrap_SbPList_removeFast, METH_VARARGS, NULL},
	 { "SbPList_getLength", _wrap_SbPList_getLength, METH_O, NULL},
	 { "SbPList_truncate", _wrap_SbPList_truncate, METH_VARARGS, NULL},
	 { "SbPList_getArrayPtr", _wrap_SbPList_getArrayPtr, METH_VARARGS, NULL},
	 { "SbPList___eq__", _wrap_SbPList___eq__, METH_VARARGS, NULL},
	 { "SbPList___ne__", _wrap_SbPList___ne__, METH_VARARGS, NULL},
	 { "SbPList_get", _wrap_SbPList_get, METH_VARARGS, NULL},
	 { "SbPList_set", _wrap_SbPList_set, METH_VARARGS, NULL},
	 { "SbPList___getitem__", _wrap_SbPList___getitem__, METH_VARARGS, NULL},
	 { "SbPList___setitem__", _wrap_SbPList___setitem__, METH_VARARGS, NULL},
	 { "SbPList_swigregister", SbPList_swigregister, METH_O, NULL},
	 { "SbPList_swiginit", SbPList_swiginit, METH_VARARGS, NULL},
	 { "new_SbIntList", _wrap_new_SbIntList, METH_VARARGS, NULL},
	 { "SbIntList_append", _wrap_SbIntList_append, METH_VARARGS, NULL},
	 { "SbIntList_find", _wrap_SbIntList_find, METH_VARARGS, NULL},
	 { "SbIntList_insert", _wrap_SbIntList_insert, METH_VARARGS, NULL},
	 { "SbIntList___setitem__", _wrap_SbIntList___setitem__, METH_VARARGS, NULL},
	 { "SbIntList___getitem__", _wrap_SbIntList___getitem__, METH_VARARGS, NULL},
	 { "SbIntList_get", _wrap_SbIntList_get, METH_VARARGS, NULL},
	 { "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, NULL},
	 { "delete_SbString", _wrap_delete_SbString, METH_O, NULL},
	 { "SbString_hash", _wrap_SbString_hash, METH_VARARGS, NULL},
	 { "SbString_getLength", _wrap_SbString_getLength, METH_O, NULL},
	 { "SbString_makeEmpty", _wrap_SbString_makeEmpty, METH_VARARGS, NULL},
	 { "SbString_getString", _wrap_SbString_getString, METH_O, NULL},
	 { "SbString_getSubString", _wrap_SbString_getSubString, METH_VARARGS, NULL},
	 { "SbString_deleteSubString", _wrap_SbString_deleteSubString, METH_VARARGS, NULL},
	 { "SbString_addIntString", _wrap_SbString_addIntString, METH_VARARGS, NULL},
	 { "SbString___iadd__", _wrap_SbString___iadd__, METH_VARARGS, NULL},
	 { "SbString_compareSubString", _wrap_SbString_compareSubString, METH_VARARGS, NULL},
	 { "SbString_sprintf", _wrap_SbString_sprintf, METH_VARARGS, NULL},
	 { "SbString_apply", _wrap_SbString_apply, METH_VARARGS, NULL},
	 { "SbString_find", _wrap_SbString_find, METH_VARARGS, NULL},
	 { "SbString_findAll", _wrap_SbString_findAll, METH_VARARGS, NULL},
	 { "SbString_lower", _wrap_SbString_lower, METH_O, NULL},
	 { "SbString_upper", _wrap_SbString_upper, METH_O, NULL},
	 { "SbString__print", _wrap_SbString__print, METH_VARARGS, NULL},
	 { "SbString___eq__", _wrap_SbString___eq__, METH_VARARGS, NULL},
	 { "SbString___nq__", _wrap_SbString___nq__, METH_VARARGS, NULL},
	 { "SbString___getitem__", _wrap_SbString___getitem__, METH_VARARGS, NULL},
	 { "SbString___repr__", _wrap_SbString___repr__, METH_O, NULL},
	 { "SbString_swigregister", SbString_swigregister, METH_O, NULL},
	 { "SbString_swiginit", SbString_swiginit, METH_VARARGS, NULL},
	 { "new_SbName", _wrap_new_SbName, METH_VARARGS, NULL},
	 { "delete_SbName", _wrap_delete_SbName, METH_O, NULL},
	 { "SbName_getString", _wrap_SbName_getString, METH_O, NULL},
	 { "SbName_getLength", _wrap_SbName_getLength, METH_O, NULL},
	 { "SbName_isIdentStartChar", _wrap_SbName_isIdentStartChar, METH_O, NULL},
	 { "SbName_isIdentChar", _wrap_SbName_isIdentChar, METH_O, NULL},
	 { "SbName_isBaseNameStartChar", _wrap_SbName_isBaseNameStartChar, METH_O, NULL},
	 { "SbName_isBaseNameChar", _wrap_SbName_isBaseNameChar, METH_O, NULL},
	 { "SbName_empty", _wrap_SbName_empty, METH_NOARGS, NULL},
	 { "SbName___eq__", _wrap_SbName___eq__, METH_VARARGS, NULL},
	 { "SbName___nq__", _wrap_SbName___nq__, METH_VARARGS, NULL},
	 { "SbName___getitem__", _wrap_SbName___getitem__, METH_VARARGS, NULL},
	 { "SbName___repr__", _wrap_SbName___repr__, METH_O, NULL},
	 { "SbName_swigregister", SbName_swigregister, METH_O, NULL},
	 { "SbName_swiginit", SbName_swiginit, METH_VARARGS, NULL},
	 { "new_SoError", _wrap_new_SoError, METH_NOARGS, NULL},
	 { "delete_SoError", _wrap_delete_SoError, METH_O, NULL},
	 { "SoError_setHandlerCallback", _wrap_SoError_setHandlerCallback, METH_VARARGS, NULL},
	 { "SoError_getHandlerCallback", _wrap_SoError_getHandlerCallback, METH_NOARGS, NULL},
	 { "SoError_getHandlerData", _wrap_SoError_getHandlerData, METH_NOARGS, NULL},
	 { "SoError_getDebugString", _wrap_SoError_getDebugString, METH_O, NULL},
	 { "SoError_getClassTypeId", _wrap_SoError_getClassTypeId, METH_NOARGS, NULL},
	 { "SoError_getTypeId", _wrap_SoError_getTypeId, METH_O, NULL},
	 { "SoError_isOfType", _wrap_SoError_isOfType, METH_VARARGS, NULL},
	 { "SoError_post", _wrap_SoError_post, METH_VARARGS, NULL},
	 { "SoError_getString", _wrap_SoError_getString, METH_VARARGS, NULL},
	 { "SoError_initClass", _wrap_SoError_initClass, METH_NOARGS, NULL},
	 { "SoError_initClasses", _wrap_SoError_initClasses, METH_NOARGS, NULL},
	 { "SoError_swigregister", SoError_swigregister, METH_O, NULL},
	 { "SoError_swiginit", SoError_swiginit, METH_VARARGS, NULL},
	 { "SoDebugError_setHandlerCallback", _wrap_SoDebugError_setHandlerCallback, METH_VARARGS, NULL},
	 { "SoDebugError_getHandlerCallback", _wrap_SoDebugError_getHandlerCallback, METH_NOARGS, NULL},
	 { "SoDebugError_getHandlerData", _wrap_SoDebugError_getHandlerData, METH_NOARGS, NULL},
	 { "SoDebugError_getClassTypeId", _wrap_SoDebugError_getClassTypeId, METH_NOARGS, NULL},
	 { "SoDebugError_getTypeId", _wrap_SoDebugError_getTypeId, METH_O, NULL},
	 { "SoDebugError_getSeverity", _wrap_SoDebugError_getSeverity, METH_O, NULL},
	 { "SoDebugError_post", _wrap_SoDebugError_post, METH_VARARGS, NULL},
	 { "SoDebugError_postWarning", _wrap_SoDebugError_postWarning, METH_VARARGS, NULL},
	 { "SoDebugError_postInfo", _wrap_SoDebugError_postInfo, METH_VARARGS, NULL},
	 { "SoDebugError_initClass", _wrap_SoDebugError_initClass, METH_NOARGS, NULL},
	 { "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, NULL},
	 { "SbVec2s_setValue", _wrap_SbVec2s_setValue, METH_VARARGS, NULL},
	 { "SbVec2s_getValue", _wrap_SbVec2s_getValue, METH_O, NULL},
	 { "SbVec2s_dot", _wrap_SbVec2s_dot, METH_VARARGS, NULL},
	 { "SbVec2s_negate", _wrap_SbVec2s_negate, METH_O, NULL},
	 { "SbVec2s___imul__", _wrap_SbVec2s___imul__, METH_VARARGS, NULL},
	 { "SbVec2s___itruediv__", _wrap_SbVec2s___itruediv__, METH_VARARGS, NULL},
	 { "SbVec2s___iadd__", _wrap_SbVec2s___iadd__, METH_VARARGS, NULL},
	 { "SbVec2s___isub__", _wrap_SbVec2s___isub__, METH_VARARGS, NULL},
	 { "SbVec2s___neg__", _wrap_SbVec2s___neg__, METH_O, NULL},
	 { "SbVec2s_toString", _wrap_SbVec2s_toString, METH_O, NULL},
	 { "SbVec2s_fromString", _wrap_SbVec2s_fromString, METH_VARARGS, NULL},
	 { "SbVec2s_output", _wrap_SbVec2s_output, METH_VARARGS, NULL},
	 { "SbVec2s___add__", _wrap_SbVec2s___add__, METH_VARARGS, NULL},
	 { "SbVec2s___sub__", _wrap_SbVec2s___sub__, METH_VARARGS, NULL},
	 { "SbVec2s___mul__", _wrap_SbVec2s___mul__, METH_VARARGS, NULL},
	 { "SbVec2s___rmul__", _wrap_SbVec2s___rmul__, METH_VARARGS, NULL},
	 { "SbVec2s___div__", _wrap_SbVec2s___div__, METH_VARARGS, NULL},
	 { "SbVec2s___truediv__", _wrap_SbVec2s___truediv__, METH_VARARGS, NULL},
	 { "SbVec2s___eq__", _wrap_SbVec2s___eq__, METH_VARARGS, NULL},
	 { "SbVec2s___nq__", _wrap_SbVec2s___nq__, METH_VARARGS, NULL},
	 { "SbVec2s___getitem__", _wrap_SbVec2s___getitem__, METH_VARARGS, NULL},
	 { "SbVec2s___setitem__", _wrap_SbVec2s___setitem__, METH_VARARGS, NULL},
	 { "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, NULL},
	 { "SbVec2f_setValue", _wrap_SbVec2f_setValue, METH_VARARGS, NULL},
	 { "SbVec2f_getValue", _wrap_SbVec2f_getValue, METH_O, NULL},
	 { "SbVec2f_dot", _wrap_SbVec2f_dot, METH_VARARGS, NULL},
	 { "SbVec2f_equals", _wrap_SbVec2f_equals, METH_VARARGS, NULL},
	 { "SbVec2f_length", _wrap_SbVec2f_length, METH_O, NULL},
	 { "SbVec2f_sqrLength", _wrap_SbVec2f_sqrLength, METH_O, NULL},
	 { "SbVec2f_negate", _wrap_SbVec2f_negate, METH_O, NULL},
	 { "SbVec2f_normalize", _wrap_SbVec2f_normalize, METH_O, NULL},
	 { "SbVec2f___imul__", _wrap_SbVec2f___imul__, METH_VARARGS, NULL},
	 { "SbVec2f___itruediv__", _wrap_SbVec2f___itruediv__, METH_VARARGS, NULL},
	 { "SbVec2f___iadd__", _wrap_SbVec2f___iadd__, METH_VARARGS, NULL},
	 { "SbVec2f___isub__", _wrap_SbVec2f___isub__, METH_VARARGS, NULL},
	 { "SbVec2f___neg__", _wrap_SbVec2f___neg__, METH_O, NULL},
	 { "SbVec2f_toString", _wrap_SbVec2f_toString, METH_O, NULL},
	 { "SbVec2f_fromString", _wrap_SbVec2f_fromString, METH_VARARGS, NULL},
	 { "SbVec2f_output", _wrap_SbVec2f_output, METH_VARARGS, NULL},
	 { "SbVec2f___add__", _wrap_SbVec2f___add__, METH_VARARGS, NULL},
	 { "SbVec2f___sub__", _wrap_SbVec2f___sub__, METH_VARARGS, NULL},
	 { "SbVec2f___mul__", _wrap_SbVec2f___mul__, METH_VARARGS, NULL},
	 { "SbVec2f___rmul__", _wrap_SbVec2f___rmul__, METH_VARARGS, NULL},
	 { "SbVec2f___div__", _wrap_SbVec2f___div__, METH_VARARGS, NULL},
	 { "SbVec2f___truediv__", _wrap_SbVec2f___truediv__, METH_VARARGS, NULL},
	 { "SbVec2f___eq__", _wrap_SbVec2f___eq__, METH_VARARGS, NULL},
	 { "SbVec2f___nq__", _wrap_SbVec2f___nq__, METH_VARARGS, NULL},
	 { "SbVec2f___getitem__", _wrap_SbVec2f___getitem__, METH_VARARGS, NULL},
	 { "SbVec2f___setitem__", _wrap_SbVec2f___setitem__, METH_VARARGS, NULL},
	 { "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, NULL},
	 { "SbTime_getTimeOfDay", _wrap_SbTime_getTimeOfDay, METH_NOARGS, NULL},
	 { "SbTime_setToTimeOfDay", _wrap_SbTime_setToTimeOfDay, METH_O, NULL},
	 { "SbTime_zero", _wrap_SbTime_zero, METH_NOARGS, NULL},
	 { "SbTime_max", _wrap_SbTime_max, METH_NOARGS, NULL},
	 { "SbTime_maxTime", _wrap_SbTime_maxTime, METH_NOARGS, NULL},
	 { "SbTime_sleep", _wrap_SbTime_sleep, METH_O, NULL},
	 { "SbTime_setValue", _wrap_SbTime_setValue, METH_VARARGS, NULL},
	 { "SbTime_setMsecValue", _wrap_SbTime_setMsecValue, METH_VARARGS, NULL},
	 { "SbTime_getValue", _wrap_SbTime_getValue, METH_VARARGS, NULL},
	 { "SbTime_getMsecValue", _wrap_SbTime_getMsecValue, METH_O, NULL},
	 { "SbTime_format", _wrap_SbTime_format, METH_VARARGS, NULL},
	 { "SbTime_formatDate", _wrap_SbTime_formatDate, METH_VARARGS, NULL},
	 { "SbTime_parsedate", _wrap_SbTime_parsedate, METH_VARARGS, NULL},
	 { "SbTime___iadd__", _wrap_SbTime___iadd__, METH_VARARGS, NULL},
	 { "SbTime___isub__", _wrap_SbTime___isub__, METH_VARARGS, NULL},
	 { "SbTime___neg__", _wrap_SbTime___neg__, METH_O, NULL},
	 { "SbTime___imul__", _wrap_SbTime___imul__, METH_VARARGS, NULL},
	 { "SbTime___itruediv__", _wrap_SbTime___itruediv__, METH_VARARGS, NULL},
	 { "SbTime___truediv__", _wrap_SbTime___truediv__, METH_VARARGS, NULL},
	 { "SbTime___mod__", _wrap_SbTime___mod__, METH_VARARGS, NULL},
	 { "SbTime___eq__", _wrap_SbTime___eq__, METH_VARARGS, NULL},
	 { "SbTime___ne__", _wrap_SbTime___ne__, METH_VARARGS, NULL},
	 { "SbTime___lt__", _wrap_SbTime___lt__, METH_VARARGS, NULL},
	 { "SbTime___gt__", _wrap_SbTime___gt__, METH_VARARGS, NULL},
	 { "SbTime___le__", _wrap_SbTime___le__, METH_VARARGS, NULL},
	 { "SbTime___ge__", _wrap_SbTime___ge__, METH_VARARGS, NULL},
	 { "SbTime_output", _wrap_SbTime_output, METH_VARARGS, NULL},
	 { "SbTime___add__", _wrap_SbTime___add__, METH_VARARGS, NULL},
	 { "SbTime___sub__", _wrap_SbTime___sub__, METH_VARARGS, NULL},
	 { "SbTime___mul__", _wrap_SbTime___mul__, METH_VARARGS, NULL},
	 { "SbTime___rmul__", _wrap_SbTime___rmul__, METH_VARARGS, NULL},
	 { "SbTime___div__", _wrap_SbTime___div__, METH_VARARGS, NULL},
	 { "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, NULL},
	 { "SoEvent_getTypeId", _wrap_SoEvent_getTypeId, METH_O, NULL},
	 { "SoEvent_initClass", _wrap_SoEvent_initClass, METH_NOARGS, NULL},
	 { "new_SoEvent", _wrap_new_SoEvent, METH_NOARGS, NULL},
	 { "delete_SoEvent", _wrap_delete_SoEvent, METH_O, NULL},
	 { "SoEvent_isOfType", _wrap_SoEvent_isOfType, METH_VARARGS, NULL},
	 { "SoEvent_setTime", _wrap_SoEvent_setTime, METH_VARARGS, NULL},
	 { "SoEvent_getTime", _wrap_SoEvent_getTime, METH_O, NULL},
	 { "SoEvent_setPosition", _wrap_SoEvent_setPosition, METH_VARARGS, NULL},
	 { "SoEvent_getPosition", _wrap_SoEvent_getPosition, METH_VARARGS, NULL},
	 { "SoEvent_getNormalizedPosition", _wrap_SoEvent_getNormalizedPosition, METH_VARARGS, NULL},
	 { "SoEvent_setShiftDown", _wrap_SoEvent_setShiftDown, METH_VARARGS, NULL},
	 { "SoEvent_wasShiftDown", _wrap_SoEvent_wasShiftDown, METH_O, NULL},
	 { "SoEvent_setCtrlDown", _wrap_SoEvent_setCtrlDown, METH_VARARGS, NULL},
	 { "SoEvent_wasCtrlDown", _wrap_SoEvent_wasCtrlDown, METH_O, NULL},
	 { "SoEvent_setAltDown", _wrap_SoEvent_setAltDown, METH_VARARGS, NULL},
	 { "SoEvent_wasAltDown", _wrap_SoEvent_wasAltDown, METH_O, NULL},
	 { "SoEvent_swigregister", SoEvent_swigregister, METH_O, NULL},
	 { "SoEvent_swiginit", SoEvent_swiginit, METH_VARARGS, NULL},
	 { "new_SoNotRec", _wrap_new_SoNotRec, METH_O, NULL},
	 { "SoNotRec_setType", _wrap_SoNotRec_setType, METH_VARARGS, NULL},
	 { "SoNotRec_getBase", _wrap_SoNotRec_getBase, METH_O, NULL},
	 { "SoNotRec_getType", _wrap_SoNotRec_getType, METH_O, NULL},
	 { "SoNotRec_getPrevious", _wrap_SoNotRec_getPrevious, METH_O, NULL},
	 { "SoNotRec_setPrevious", _wrap_SoNotRec_setPrevious, METH_VARARGS, NULL},
	 { "SoNotRec_output", _wrap_SoNotRec_output, METH_VARARGS, NULL},
	 { "SoNotRec_getOperationType", _wrap_SoNotRec_getOperationType, METH_O, NULL},
	 { "SoNotRec_getIndex", _wrap_SoNotRec_getIndex, METH_O, NULL},
	 { "SoNotRec_getFieldNumIndices", _wrap_SoNotRec_getFieldNumIndices, METH_O, NULL},
	 { "SoNotRec_getGroupChild", _wrap_SoNotRec_getGroupChild, METH_O, NULL},
	 { "SoNotRec_getGroupPrevChild", _wrap_SoNotRec_getGroupPrevChild, METH_O, NULL},
	 { "SoNotRec_setOperationType", _wrap_SoNotRec_setOperationType, METH_VARARGS, NULL},
	 { "SoNotRec_setIndex", _wrap_SoNotRec_setIndex, METH_VARARGS, NULL},
	 { "SoNotRec_setFieldNumIndices", _wrap_SoNotRec_setFieldNumIndices, METH_VARARGS, NULL},
	 { "SoNotRec_setGroupChild", _wrap_SoNotRec_setGroupChild, METH_VARARGS, NULL},
	 { "SoNotRec_setGroupPrevChild", _wrap_SoNotRec_setGroupPrevChild, METH_VARARGS, NULL},
	 { "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, NULL},
	 { "SoNotList_append", _wrap_SoNotList_append, METH_VARARGS, NULL},
	 { "SoNotList_setLastType", _wrap_SoNotList_setLastType, METH_VARARGS, NULL},
	 { "SoNotList_getFirstRec", _wrap_SoNotList_getFirstRec, METH_O, NULL},
	 { "SoNotList_getLastRec", _wrap_SoNotList_getLastRec, METH_O, NULL},
	 { "SoNotList_getFirstRecAtNode", _wrap_SoNotList_getFirstRecAtNode, METH_O, NULL},
	 { "SoNotList_getLastField", _wrap_SoNotList_getLastField, METH_O, NULL},
	 { "SoNotList_getLastEngineOutput", _wrap_SoNotList_getLastEngineOutput, METH_O, NULL},
	 { "SoNotList_getTimeStamp", _wrap_SoNotList_getTimeStamp, METH_O, NULL},
	 { "SoNotList_output", _wrap_SoNotList_output, METH_VARARGS, NULL},
	 { "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, NULL},
	 { "SoField_initClass", _wrap_SoField_initClass, METH_NOARGS, NULL},
	 { "SoField_initClasses", _wrap_SoField_initClasses, METH_NOARGS, NULL},
	 { "SoField_cleanupClass", _wrap_SoField_cleanupClass, METH_NOARGS, NULL},
	 { "SoField_setIgnored", _wrap_SoField_setIgnored, METH_VARARGS, NULL},
	 { "SoField_isIgnored", _wrap_SoField_isIgnored, METH_O, NULL},
	 { "SoField_setDefault", _wrap_SoField_setDefault, METH_VARARGS, NULL},
	 { "SoField_isDefault", _wrap_SoField_isDefault, METH_O, NULL},
	 { "SoField_getTypeId", _wrap_SoField_getTypeId, METH_O, NULL},
	 { "SoField_getClassTypeId", _wrap_SoField_getClassTypeId, METH_NOARGS, NULL},
	 { "SoField_isOfType", _wrap_SoField_isOfType, METH_VARARGS, NULL},
	 { "SoField_enableConnection", _wrap_SoField_enableConnection, METH_VARARGS, NULL},
	 { "SoField_isConnectionEnabled", _wrap_SoField_isConnectionEnabled, METH_O, NULL},
	 { "SoField_isConnectedFromEngine", _wrap_SoField_isConnectedFromEngine, METH_O, NULL},
	 { "SoField_getConnectedEngine", _wrap_SoField_getConnectedEngine, METH_VARARGS, NULL},
	 { "SoField_connectFrom", _wrap_SoField_connectFrom, METH_VARARGS, NULL},
	 { "SoField_appendConnection", _wrap_SoField_appendConnection, METH_VARARGS, NULL},
	 { "SoField_isConnectedFromField", _wrap_SoField_isConnectedFromField, METH_O, NULL},
	 { "SoField_getConnectedField", _wrap_SoField_getConnectedField, METH_VARARGS, NULL},
	 { "SoField_getNumConnections", _wrap_SoField_getNumConnections, METH_O, NULL},
	 { "SoField_getForwardConnections", _wrap_SoField_getForwardConnections, METH_VARARGS, NULL},
	 { "SoField_getConnections", _wrap_SoField_getConnections, METH_VARARGS, NULL},
	 { "SoField_disconnect", _wrap_SoField_disconnect, METH_VARARGS, NULL},
	 { "SoField_isConnected", _wrap_SoField_isConnected, METH_O, NULL},
	 { "SoField_setContainer", _wrap_SoField_setContainer, METH_VARARGS, NULL},
	 { "SoField_getContainer", _wrap_SoField_getContainer, METH_O, NULL},
	 { "SoField_set", _wrap_SoField_set, METH_VARARGS, NULL},
	 { "SoField_shouldWrite", _wrap_SoField_shouldWrite, METH_O, NULL},
	 { "SoField_touch", _wrap_SoField_touch, METH_O, NULL},
	 { "SoField_startNotify", _wrap_SoField_startNotify, METH_O, NULL},
	 { "SoField_notify", _wrap_SoField_notify, METH_VARARGS, NULL},
	 { "SoField_enableNotify", _wrap_SoField_enableNotify, METH_VARARGS, NULL},
	 { "SoField_isNotifyEnabled", _wrap_SoField_isNotifyEnabled, METH_O, NULL},
	 { "SoField_addAuditor", _wrap_SoField_addAuditor, METH_VARARGS, NULL},
	 { "SoField_removeAuditor", _wrap_SoField_removeAuditor, METH_VARARGS, NULL},
	 { "SoField___eq__", _wrap_SoField___eq__, METH_VARARGS, NULL},
	 { "SoField___ne__", _wrap_SoField___ne__, METH_VARARGS, NULL},
	 { "SoField_connectionStatusChanged", _wrap_SoField_connectionStatusChanged, METH_VARARGS, NULL},
	 { "SoField_isReadOnly", _wrap_SoField_isReadOnly, METH_O, NULL},
	 { "SoField_isSame", _wrap_SoField_isSame, METH_VARARGS, NULL},
	 { "SoField_copyFrom", _wrap_SoField_copyFrom, METH_VARARGS, NULL},
	 { "SoField_fixCopy", _wrap_SoField_fixCopy, METH_VARARGS, NULL},
	 { "SoField_referencesCopy", _wrap_SoField_referencesCopy, METH_O, NULL},
	 { "SoField_copyConnection", _wrap_SoField_copyConnection, METH_VARARGS, NULL},
	 { "SoField_read", _wrap_SoField_read, METH_VARARGS, NULL},
	 { "SoField_write", _wrap_SoField_write, METH_VARARGS, NULL},
	 { "SoField_countWriteRefs", _wrap_SoField_countWriteRefs, METH_VARARGS, NULL},
	 { "SoField_setFieldType", _wrap_SoField_setFieldType, METH_VARARGS, NULL},
	 { "SoField_getFieldType", _wrap_SoField_getFieldType, METH_O, NULL},
	 { "SoField_getDirty", _wrap_SoField_getDirty, METH_O, NULL},
	 { "SoField_setDirty", _wrap_SoField_setDirty, METH_VARARGS, NULL},
	 { "SoField_evaluate", _wrap_SoField_evaluate, METH_O, NULL},
	 { "SoField_get", _wrap_SoField_get, METH_O, NULL},
	 { "SoField_swigregister", SoField_swigregister, METH_O, NULL},
	 { "delete_SoSField", _wrap_delete_SoSField, METH_O, NULL},
	 { "SoSField_initClass", _wrap_SoSField_initClass, METH_NOARGS, NULL},
	 { "SoSField_getClassTypeId", _wrap_SoSField_getClassTypeId, METH_NOARGS, NULL},
	 { "SoSField_atexit_cleanup", _wrap_SoSField_atexit_cleanup, METH_NOARGS, NULL},
	 { "SoSField_swigregister", SoSField_swigregister, METH_O, NULL},
	 { "delete_SoMField", _wrap_delete_SoMField, METH_O, NULL},
	 { "SoMField_getClassTypeId", _wrap_SoMField_getClassTypeId, METH_NOARGS, NULL},
	 { "SoMField_atexit_cleanup", _wrap_SoMField_atexit_cleanup, METH_NOARGS, NULL},
	 { "SoMField_getNum", _wrap_SoMField_getNum, METH_O, NULL},
	 { "SoMField_setNum", _wrap_SoMField_setNum, METH_VARARGS, NULL},
	 { "SoMField_deleteValues", _wrap_SoMField_deleteValues, METH_VARARGS, NULL},
	 { "SoMField_insertSpace", _wrap_SoMField_insertSpace, METH_VARARGS, NULL},
	 { "SoMField_set1", _wrap_SoMField_set1, METH_VARARGS, NULL},
	 { "SoMField_initClass", _wrap_SoMField_initClass, METH_NOARGS, NULL},
	 { "SoMField_enableDeleteValues", _wrap_SoMField_enableDeleteValues, METH_O, NULL},
	 { "SoMField_isDeleteValuesEnabled", _wrap_SoMField_isDeleteValuesEnabled, METH_O, NULL},
	 { "SoMField___len__", _wrap_SoMField___len__, METH_O, NULL},
	 { "SoMField_get1", _wrap_SoMField_get1, METH_VARARGS, NULL},
	 { "SoMField_swigregister", SoMField_swigregister, METH_O, NULL},
	 { "delete_QEvent", _wrap_delete_QEvent, METH_O, "delete_QEvent(QEvent self)"},
	 { "QEvent_swigregister", QEvent_swigregister, METH_O, NULL},
	 { "delete_QWidget", _wrap_delete_QWidget, METH_O, "delete_QWidget(QWidget self)"},
	 { "QWidget_swigregister", QWidget_swigregister, METH_O, NULL},
	 { "SoQtObject_initClass", _wrap_SoQtObject_initClass, METH_NOARGS, "SoQtObject_initClass()"},
	 { "SoQtObject_getClassTypeId", _wrap_SoQtObject_getClassTypeId, METH_NOARGS, "SoQtObject_getClassTypeId() -> SoType"},
	 { "SoQtObject_getTypeId", _wrap_SoQtObject_getTypeId, METH_O, "SoQtObject_getTypeId(SoQtObject self) -> SoType"},
	 { "SoQtObject_isOfType", _wrap_SoQtObject_isOfType, METH_VARARGS, "SoQtObject_isOfType(SoQtObject self, SoType type) -> SbBool"},
	 { "SoQtObject_init", _wrap_SoQtObject_init, METH_NOARGS, "SoQtObject_init()"},
	 { "delete_SoQtObject", _wrap_delete_SoQtObject, METH_O, "delete_SoQtObject(SoQtObject self)"},
	 { "SoQtObject_swigregister", SoQtObject_swigregister, METH_O, NULL},
	 { "SoQtDevice_initClass", _wrap_SoQtDevice_initClass, METH_NOARGS, "SoQtDevice_initClass()"},
	 { "SoQtDevice_getClassTypeId", _wrap_SoQtDevice_getClassTypeId, METH_NOARGS, "SoQtDevice_getClassTypeId() -> SoType"},
	 { "SoQtDevice_getTypeId", _wrap_SoQtDevice_getTypeId, METH_O, "SoQtDevice_getTypeId(SoQtDevice self) -> SoType"},
	 { "delete_SoQtDevice", _wrap_delete_SoQtDevice, METH_O, "delete_SoQtDevice(SoQtDevice self)"},
	 { "SoQtDevice_enable", _wrap_SoQtDevice_enable, METH_VARARGS, "SoQtDevice_enable(SoQtDevice self, QWidget w, SoQtEventHandler * handler, void * closure)"},
	 { "SoQtDevice_disable", _wrap_SoQtDevice_disable, METH_VARARGS, "SoQtDevice_disable(SoQtDevice self, QWidget w, SoQtEventHandler * handler, void * closure)"},
	 { "SoQtDevice_translateEvent", _wrap_SoQtDevice_translateEvent, METH_VARARGS, "SoQtDevice_translateEvent(SoQtDevice self, QEvent event) -> SoEvent"},
	 { "SoQtDevice_setWindowSize", _wrap_SoQtDevice_setWindowSize, METH_VARARGS, "SoQtDevice_setWindowSize(SoQtDevice self, SbVec2s size)"},
	 { "SoQtDevice_getWindowSize", _wrap_SoQtDevice_getWindowSize, METH_O, "SoQtDevice_getWindowSize(SoQtDevice self) -> SbVec2s"},
	 { "SoQtDevice_initClasses", _wrap_SoQtDevice_initClasses, METH_NOARGS, "SoQtDevice_initClasses()"},
	 { "SoQtDevice_swigregister", SoQtDevice_swigregister, METH_O, NULL},
	 { "SoQtKeyboard_initClass", _wrap_SoQtKeyboard_initClass, METH_NOARGS, "SoQtKeyboard_initClass()"},
	 { "SoQtKeyboard_getClassTypeId", _wrap_SoQtKeyboard_getClassTypeId, METH_NOARGS, "SoQtKeyboard_getClassTypeId() -> SoType"},
	 { "SoQtKeyboard_getTypeId", _wrap_SoQtKeyboard_getTypeId, METH_O, "SoQtKeyboard_getTypeId(SoQtKeyboard self) -> SoType"},
	 { "SoQtKeyboard_createInstance", _wrap_SoQtKeyboard_createInstance, METH_NOARGS, "SoQtKeyboard_createInstance() -> void *"},
	 { "new_SoQtKeyboard", _wrap_new_SoQtKeyboard, METH_VARARGS, "SoQtKeyboard(int eventmask=ALL_EVENTS)"},
	 { "delete_SoQtKeyboard", _wrap_delete_SoQtKeyboard, METH_O, "delete_SoQtKeyboard(SoQtKeyboard self)"},
	 { "SoQtKeyboard_enable", _wrap_SoQtKeyboard_enable, METH_VARARGS, "SoQtKeyboard_enable(SoQtKeyboard self, QWidget widget, SoQtEventHandler * handler, void * closure)"},
	 { "SoQtKeyboard_disable", _wrap_SoQtKeyboard_disable, METH_VARARGS, "SoQtKeyboard_disable(SoQtKeyboard self, QWidget widget, SoQtEventHandler * handler, void * closure)"},
	 { "SoQtKeyboard_translateEvent", _wrap_SoQtKeyboard_translateEvent, METH_VARARGS, "SoQtKeyboard_translateEvent(SoQtKeyboard self, QEvent event) -> SoEvent"},
	 { "SoQtKeyboard_swigregister", SoQtKeyboard_swigregister, METH_O, NULL},
	 { "SoQtKeyboard_swiginit", SoQtKeyboard_swiginit, METH_VARARGS, NULL},
	 { "SoQtMouse_initClass", _wrap_SoQtMouse_initClass, METH_NOARGS, "SoQtMouse_initClass()"},
	 { "SoQtMouse_getClassTypeId", _wrap_SoQtMouse_getClassTypeId, METH_NOARGS, "SoQtMouse_getClassTypeId() -> SoType"},
	 { "SoQtMouse_getTypeId", _wrap_SoQtMouse_getTypeId, METH_O, "SoQtMouse_getTypeId(SoQtMouse self) -> SoType"},
	 { "SoQtMouse_createInstance", _wrap_SoQtMouse_createInstance, METH_NOARGS, "SoQtMouse_createInstance() -> void *"},
	 { "new_SoQtMouse", _wrap_new_SoQtMouse, METH_VARARGS, "SoQtMouse(int eventmask=ALL_EVENTS)"},
	 { "delete_SoQtMouse", _wrap_delete_SoQtMouse, METH_O, "delete_SoQtMouse(SoQtMouse self)"},
	 { "SoQtMouse_enable", _wrap_SoQtMouse_enable, METH_VARARGS, "SoQtMouse_enable(SoQtMouse self, QWidget widget, SoQtEventHandler * handler, void * closure)"},
	 { "SoQtMouse_disable", _wrap_SoQtMouse_disable, METH_VARARGS, "SoQtMouse_disable(SoQtMouse self, QWidget widget, SoQtEventHandler * handler, void * closure)"},
	 { "SoQtMouse_translateEvent", _wrap_SoQtMouse_translateEvent, METH_VARARGS, "SoQtMouse_translateEvent(SoQtMouse self, QEvent event) -> SoEvent"},
	 { "SoQtMouse_swigregister", SoQtMouse_swigregister, METH_O, NULL},
	 { "SoQtMouse_swiginit", SoQtMouse_swiginit, METH_VARARGS, NULL},
	 { "SoQt_init", _wrap_SoQt_init, METH_VARARGS, "\n"
		"SoQt_init(char const * appname, char const * classname=\"SoQt\") -> QWidget\n"
		"SoQt_init(int & argc, char ** argv, char const * appname, char const * classname=\"SoQt\") -> QWidget\n"
		"SoQt_init(QWidget toplevelwidget)\n"
		""},
	 { "SoQt_exitMainLoop", _wrap_SoQt_exitMainLoop, METH_NOARGS, "SoQt_exitMainLoop()"},
	 { "SoQt_done", _wrap_SoQt_done, METH_NOARGS, "SoQt_done()"},
	 { "SoQt_getTopLevelWidget", _wrap_SoQt_getTopLevelWidget, METH_NOARGS, "SoQt_getTopLevelWidget() -> QWidget"},
	 { "SoQt_getShellWidget", _wrap_SoQt_getShellWidget, METH_O, "SoQt_getShellWidget(QWidget w) -> QWidget"},
	 { "SoQt_show", _wrap_SoQt_show, METH_O, "SoQt_show(QWidget widget)"},
	 { "SoQt_hide", _wrap_SoQt_hide, METH_O, "SoQt_hide(QWidget widget)"},
	 { "SoQt_setWidgetSize", _wrap_SoQt_setWidgetSize, METH_VARARGS, "SoQt_setWidgetSize(QWidget widget, SbVec2s size)"},
	 { "SoQt_getWidgetSize", _wrap_SoQt_getWidgetSize, METH_O, "SoQt_getWidgetSize(QWidget widget) -> SbVec2s"},
	 { "SoQt_createSimpleErrorDialog", _wrap_SoQt_createSimpleErrorDialog, METH_VARARGS, "SoQt_createSimpleErrorDialog(QWidget widget, char const * title, char const * string1, char const * string2=None)"},
	 { "SoQt_getVersionInfo", _wrap_SoQt_getVersionInfo, METH_VARARGS, "SoQt_getVersionInfo(int * major=None, int * minor=None, int * micro=None)"},
	 { "SoQt_getVersionString", _wrap_SoQt_getVersionString, METH_NOARGS, "SoQt_getVersionString() -> char const *"},
	 { "SoQt_getVersionToolkitString", _wrap_SoQt_getVersionToolkitString, METH_NOARGS, "SoQt_getVersionToolkitString() -> char const *"},
	 { "SoQt_setFatalErrorHandler", _wrap_SoQt_setFatalErrorHandler, METH_VARARGS, "SoQt_setFatalErrorHandler(SoQt::FatalErrorCB * cb, void * userdata) -> SoQt::FatalErrorCB *"},
	 { "SoQt_isDebugLibrary", _wrap_SoQt_isDebugLibrary, METH_NOARGS, "SoQt_isDebugLibrary() -> SbBool"},
	 { "SoQt_isCompatible", _wrap_SoQt_isCompatible, METH_VARARGS, "SoQt_isCompatible(unsigned int major, unsigned int minor) -> SbBool"},
	 { "SoQt_getABIType", _wrap_SoQt_getABIType, METH_NOARGS, "SoQt_getABIType() -> SoQt::ABIType"},
	 { "SoQt_lockGL", _wrap_SoQt_lockGL, METH_NOARGS, "SoQt_lockGL()"},
	 { "SoQt_unlockGL", _wrap_SoQt_unlockGL, METH_NOARGS, "SoQt_unlockGL()"},
	 { "SoQt_mainLoop", _wrap_SoQt_mainLoop, METH_NOARGS, "SoQt_mainLoop()"},
	 { "SoQt_swigregister", SoQt_swigregister, METH_O, NULL},
	 { "SoQtComponent_initClass", _wrap_SoQtComponent_initClass, METH_NOARGS, "SoQtComponent_initClass()"},
	 { "SoQtComponent_getClassTypeId", _wrap_SoQtComponent_getClassTypeId, METH_NOARGS, "SoQtComponent_getClassTypeId() -> SoType"},
	 { "SoQtComponent_getTypeId", _wrap_SoQtComponent_getTypeId, METH_O, "SoQtComponent_getTypeId(SoQtComponent self) -> SoType"},
	 { "delete_SoQtComponent", _wrap_delete_SoQtComponent, METH_O, "delete_SoQtComponent(SoQtComponent self)"},
	 { "SoQtComponent_show", _wrap_SoQtComponent_show, METH_O, "SoQtComponent_show(SoQtComponent self)"},
	 { "SoQtComponent_hide", _wrap_SoQtComponent_hide, METH_O, "SoQtComponent_hide(SoQtComponent self)"},
	 { "SoQtComponent_setComponentCursor", _wrap_SoQtComponent_setComponentCursor, METH_VARARGS, "SoQtComponent_setComponentCursor(SoQtComponent self, SoQtCursor cursor)"},
	 { "SoQtComponent_setWidgetCursor", _wrap_SoQtComponent_setWidgetCursor, METH_VARARGS, "SoQtComponent_setWidgetCursor(QWidget w, SoQtCursor cursor)"},
	 { "SoQtComponent_isFullScreen", _wrap_SoQtComponent_isFullScreen, METH_O, "SoQtComponent_isFullScreen(SoQtComponent self) -> SbBool"},
	 { "SoQtComponent_setFullScreen", _wrap_SoQtComponent_setFullScreen, METH_VARARGS, "SoQtComponent_setFullScreen(SoQtComponent self, SbBool const onoff) -> SbBool"},
	 { "SoQtComponent_isVisible", _wrap_SoQtComponent_isVisible, METH_O, "SoQtComponent_isVisible(SoQtComponent self) -> SbBool"},
	 { "SoQtComponent_isTopLevelShell", _wrap_SoQtComponent_isTopLevelShell, METH_O, "SoQtComponent_isTopLevelShell(SoQtComponent self) -> SbBool"},
	 { "SoQtComponent_getWidget", _wrap_SoQtComponent_getWidget, METH_O, "SoQtComponent_getWidget(SoQtComponent self) -> QWidget"},
	 { "SoQtComponent_getBaseWidget", _wrap_SoQtComponent_getBaseWidget, METH_O, "SoQtComponent_getBaseWidget(SoQtComponent self) -> QWidget"},
	 { "SoQtComponent_getShellWidget", _wrap_SoQtComponent_getShellWidget, METH_O, "SoQtComponent_getShellWidget(SoQtComponent self) -> QWidget"},
	 { "SoQtComponent_getParentWidget", _wrap_SoQtComponent_getParentWidget, METH_O, "SoQtComponent_getParentWidget(SoQtComponent self) -> QWidget"},
	 { "SoQtComponent_setSize", _wrap_SoQtComponent_setSize, METH_VARARGS, "SoQtComponent_setSize(SoQtComponent self, SbVec2s size)"},
	 { "SoQtComponent_getSize", _wrap_SoQtComponent_getSize, METH_O, "SoQtComponent_getSize(SoQtComponent self) -> SbVec2s"},
	 { "SoQtComponent_setTitle", _wrap_SoQtComponent_setTitle, METH_VARARGS, "SoQtComponent_setTitle(SoQtComponent self, char const *const title)"},
	 { "SoQtComponent_getTitle", _wrap_SoQtComponent_getTitle, METH_O, "SoQtComponent_getTitle(SoQtComponent self) -> char const *"},
	 { "SoQtComponent_setIconTitle", _wrap_SoQtComponent_setIconTitle, METH_VARARGS, "SoQtComponent_setIconTitle(SoQtComponent self, char const *const title)"},
	 { "SoQtComponent_getIconTitle", _wrap_SoQtComponent_getIconTitle, METH_O, "SoQtComponent_getIconTitle(SoQtComponent self) -> char const *"},
	 { "SoQtComponent_getWidgetName", _wrap_SoQtComponent_getWidgetName, METH_O, "SoQtComponent_getWidgetName(SoQtComponent self) -> char const *"},
	 { "SoQtComponent_getClassName", _wrap_SoQtComponent_getClassName, METH_O, "SoQtComponent_getClassName(SoQtComponent self) -> char const *"},
	 { "SoQtComponent_setWindowCloseCallback", _wrap_SoQtComponent_setWindowCloseCallback, METH_VARARGS, "SoQtComponent_setWindowCloseCallback(SoQtComponent self, SoQtComponentCB *const func, void *const user=None)"},
	 { "SoQtComponent_getComponent", _wrap_SoQtComponent_getComponent, METH_O, "SoQtComponent_getComponent(QWidget widget) -> SoQtComponent"},
	 { "SoQtComponent_initClasses", _wrap_SoQtComponent_initClasses, METH_NOARGS, "SoQtComponent_initClasses()"},
	 { "SoQtComponent_swigregister", SoQtComponent_swigregister, METH_O, NULL},
	 { "SoQtGLWidget_initClass", _wrap_SoQtGLWidget_initClass, METH_NOARGS, "SoQtGLWidget_initClass()"},
	 { "SoQtGLWidget_getClassTypeId", _wrap_SoQtGLWidget_getClassTypeId, METH_NOARGS, "SoQtGLWidget_getClassTypeId() -> SoType"},
	 { "SoQtGLWidget_getTypeId", _wrap_SoQtGLWidget_getTypeId, METH_O, "SoQtGLWidget_getTypeId(SoQtGLWidget self) -> SoType"},
	 { "SoQtGLWidget_setBorder", _wrap_SoQtGLWidget_setBorder, METH_VARARGS, "SoQtGLWidget_setBorder(SoQtGLWidget self, SbBool const enable)"},
	 { "SoQtGLWidget_isBorder", _wrap_SoQtGLWidget_isBorder, METH_O, "SoQtGLWidget_isBorder(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setDoubleBuffer", _wrap_SoQtGLWidget_setDoubleBuffer, METH_VARARGS, "SoQtGLWidget_setDoubleBuffer(SoQtGLWidget self, SbBool const enable)"},
	 { "SoQtGLWidget_isDoubleBuffer", _wrap_SoQtGLWidget_isDoubleBuffer, METH_O, "SoQtGLWidget_isDoubleBuffer(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setDrawToFrontBufferEnable", _wrap_SoQtGLWidget_setDrawToFrontBufferEnable, METH_VARARGS, "SoQtGLWidget_setDrawToFrontBufferEnable(SoQtGLWidget self, SbBool const enable)"},
	 { "SoQtGLWidget_isDrawToFrontBufferEnable", _wrap_SoQtGLWidget_isDrawToFrontBufferEnable, METH_O, "SoQtGLWidget_isDrawToFrontBufferEnable(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setQuadBufferStereo", _wrap_SoQtGLWidget_setQuadBufferStereo, METH_VARARGS, "SoQtGLWidget_setQuadBufferStereo(SoQtGLWidget self, SbBool const enable)"},
	 { "SoQtGLWidget_isQuadBufferStereo", _wrap_SoQtGLWidget_isQuadBufferStereo, METH_O, "SoQtGLWidget_isQuadBufferStereo(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setAccumulationBuffer", _wrap_SoQtGLWidget_setAccumulationBuffer, METH_VARARGS, "SoQtGLWidget_setAccumulationBuffer(SoQtGLWidget self, SbBool const enable)"},
	 { "SoQtGLWidget_getAccumulationBuffer", _wrap_SoQtGLWidget_getAccumulationBuffer, METH_O, "SoQtGLWidget_getAccumulationBuffer(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setStencilBuffer", _wrap_SoQtGLWidget_setStencilBuffer, METH_VARARGS, "SoQtGLWidget_setStencilBuffer(SoQtGLWidget self, SbBool const enable)"},
	 { "SoQtGLWidget_getStencilBuffer", _wrap_SoQtGLWidget_getStencilBuffer, METH_O, "SoQtGLWidget_getStencilBuffer(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setAlphaChannel", _wrap_SoQtGLWidget_setAlphaChannel, METH_VARARGS, "SoQtGLWidget_setAlphaChannel(SoQtGLWidget self, SbBool const enable)"},
	 { "SoQtGLWidget_getAlphaChannel", _wrap_SoQtGLWidget_getAlphaChannel, METH_O, "SoQtGLWidget_getAlphaChannel(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setOverlayRender", _wrap_SoQtGLWidget_setOverlayRender, METH_VARARGS, "SoQtGLWidget_setOverlayRender(SoQtGLWidget self, SbBool const onoff)"},
	 { "SoQtGLWidget_isOverlayRender", _wrap_SoQtGLWidget_isOverlayRender, METH_O, "SoQtGLWidget_isOverlayRender(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_setSampleBuffers", _wrap_SoQtGLWidget_setSampleBuffers, METH_VARARGS, "SoQtGLWidget_setSampleBuffers(SoQtGLWidget self, int const numsamples)"},
	 { "SoQtGLWidget_getSampleBuffers", _wrap_SoQtGLWidget_getSampleBuffers, METH_O, "SoQtGLWidget_getSampleBuffers(SoQtGLWidget self) -> int"},
	 { "SoQtGLWidget_setStealFocus", _wrap_SoQtGLWidget_setStealFocus, METH_VARARGS, "SoQtGLWidget_setStealFocus(SoQtGLWidget self, SbBool enable)"},
	 { "SoQtGLWidget_isStealFocus", _wrap_SoQtGLWidget_isStealFocus, METH_O, "SoQtGLWidget_isStealFocus(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_getGLWidget", _wrap_SoQtGLWidget_getGLWidget, METH_O, "SoQtGLWidget_getGLWidget(SoQtGLWidget self) -> QWidget"},
	 { "SoQtGLWidget_getNormalWidget", _wrap_SoQtGLWidget_getNormalWidget, METH_O, "SoQtGLWidget_getNormalWidget(SoQtGLWidget self) -> QWidget"},
	 { "SoQtGLWidget_getOverlayWidget", _wrap_SoQtGLWidget_getOverlayWidget, METH_O, "SoQtGLWidget_getOverlayWidget(SoQtGLWidget self) -> QWidget"},
	 { "SoQtGLWidget_hasOverlayGLArea", _wrap_SoQtGLWidget_hasOverlayGLArea, METH_O, "SoQtGLWidget_hasOverlayGLArea(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_hasNormalGLArea", _wrap_SoQtGLWidget_hasNormalGLArea, METH_O, "SoQtGLWidget_hasNormalGLArea(SoQtGLWidget self) -> SbBool"},
	 { "SoQtGLWidget_getOverlayTransparentPixel", _wrap_SoQtGLWidget_getOverlayTransparentPixel, METH_O, "SoQtGLWidget_getOverlayTransparentPixel(SoQtGLWidget self) -> unsigned long"},
	 { "SoQtGLWidget_getPointSizeLimits", _wrap_SoQtGLWidget_getPointSizeLimits, METH_VARARGS, "SoQtGLWidget_getPointSizeLimits(SoQtGLWidget self, SbVec2f range, float & granularity)"},
	 { "SoQtGLWidget_getLineWidthLimits", _wrap_SoQtGLWidget_getLineWidthLimits, METH_VARARGS, "SoQtGLWidget_getLineWidthLimits(SoQtGLWidget self, SbVec2f range, float & granularity)"},
	 { "SoQtGLWidget_swigregister", SoQtGLWidget_swigregister, METH_O, NULL},
	 { "SoQtRenderArea_initClass", _wrap_SoQtRenderArea_initClass, METH_NOARGS, "SoQtRenderArea_initClass()"},
	 { "SoQtRenderArea_getClassTypeId", _wrap_SoQtRenderArea_getClassTypeId, METH_NOARGS, "SoQtRenderArea_getClassTypeId() -> SoType"},
	 { "SoQtRenderArea_getTypeId", _wrap_SoQtRenderArea_getTypeId, METH_O, "SoQtRenderArea_getTypeId(SoQtRenderArea self) -> SoType"},
	 { "SoQtRenderArea_createInstance", _wrap_SoQtRenderArea_createInstance, METH_NOARGS, "SoQtRenderArea_createInstance() -> void *"},
	 { "new_SoQtRenderArea", _wrap_new_SoQtRenderArea, METH_VARARGS, "SoQtRenderArea(QWidget parent=None, char const * name=None, SbBool embed=1, SbBool mouseInput=1, SbBool keyboardInput=1)"},
	 { "delete_SoQtRenderArea", _wrap_delete_SoQtRenderArea, METH_O, "delete_SoQtRenderArea(SoQtRenderArea self)"},
	 { "SoQtRenderArea_setSceneGraph", _wrap_SoQtRenderArea_setSceneGraph, METH_VARARGS, "SoQtRenderArea_setSceneGraph(SoQtRenderArea self, SoNode scene)"},
	 { "SoQtRenderArea_getSceneGraph", _wrap_SoQtRenderArea_getSceneGraph, METH_O, "SoQtRenderArea_getSceneGraph(SoQtRenderArea self) -> SoNode"},
	 { "SoQtRenderArea_setOverlaySceneGraph", _wrap_SoQtRenderArea_setOverlaySceneGraph, METH_VARARGS, "SoQtRenderArea_setOverlaySceneGraph(SoQtRenderArea self, SoNode scene)"},
	 { "SoQtRenderArea_getOverlaySceneGraph", _wrap_SoQtRenderArea_getOverlaySceneGraph, METH_O, "SoQtRenderArea_getOverlaySceneGraph(SoQtRenderArea self) -> SoNode"},
	 { "SoQtRenderArea_setBackgroundColor", _wrap_SoQtRenderArea_setBackgroundColor, METH_VARARGS, "SoQtRenderArea_setBackgroundColor(SoQtRenderArea self, SbColor color)"},
	 { "SoQtRenderArea_getBackgroundColor", _wrap_SoQtRenderArea_getBackgroundColor, METH_O, "SoQtRenderArea_getBackgroundColor(SoQtRenderArea self) -> SbColor"},
	 { "SoQtRenderArea_setBackgroundIndex", _wrap_SoQtRenderArea_setBackgroundIndex, METH_VARARGS, "SoQtRenderArea_setBackgroundIndex(SoQtRenderArea self, int idx)"},
	 { "SoQtRenderArea_getBackgroundIndex", _wrap_SoQtRenderArea_getBackgroundIndex, METH_O, "SoQtRenderArea_getBackgroundIndex(SoQtRenderArea self) -> int"},
	 { "SoQtRenderArea_setOverlayBackgroundIndex", _wrap_SoQtRenderArea_setOverlayBackgroundIndex, METH_VARARGS, "SoQtRenderArea_setOverlayBackgroundIndex(SoQtRenderArea self, int idx)"},
	 { "SoQtRenderArea_getOverlayBackgroundIndex", _wrap_SoQtRenderArea_getOverlayBackgroundIndex, METH_O, "SoQtRenderArea_getOverlayBackgroundIndex(SoQtRenderArea self) -> int"},
	 { "SoQtRenderArea_setColorMap", _wrap_SoQtRenderArea_setColorMap, METH_VARARGS, "SoQtRenderArea_setColorMap(SoQtRenderArea self, int start, int num, SbColor colors)"},
	 { "SoQtRenderArea_setOverlayColorMap", _wrap_SoQtRenderArea_setOverlayColorMap, METH_VARARGS, "SoQtRenderArea_setOverlayColorMap(SoQtRenderArea self, int start, int num, SbColor colors)"},
	 { "SoQtRenderArea_setViewportRegion", _wrap_SoQtRenderArea_setViewportRegion, METH_VARARGS, "SoQtRenderArea_setViewportRegion(SoQtRenderArea self, SbViewportRegion newRegion)"},
	 { "SoQtRenderArea_getViewportRegion", _wrap_SoQtRenderArea_getViewportRegion, METH_O, "SoQtRenderArea_getViewportRegion(SoQtRenderArea self) -> SbViewportRegion"},
	 { "SoQtRenderArea_setTransparencyType", _wrap_SoQtRenderArea_setTransparencyType, METH_VARARGS, "SoQtRenderArea_setTransparencyType(SoQtRenderArea self, SoGLRenderAction::TransparencyType type)"},
	 { "SoQtRenderArea_getTransparencyType", _wrap_SoQtRenderArea_getTransparencyType, METH_O, "SoQtRenderArea_getTransparencyType(SoQtRenderArea self) -> SoGLRenderAction::TransparencyType"},
	 { "SoQtRenderArea_setAntialiasing", _wrap_SoQtRenderArea_setAntialiasing, METH_VARARGS, "SoQtRenderArea_setAntialiasing(SoQtRenderArea self, SbBool smoothing, int numPasses)"},
	 { "SoQtRenderArea_getAntialiasing", _wrap_SoQtRenderArea_getAntialiasing, METH_VARARGS, "SoQtRenderArea_getAntialiasing(SoQtRenderArea self, SbBool & smoothing, int & numPasses)"},
	 { "SoQtRenderArea_setClearBeforeRender", _wrap_SoQtRenderArea_setClearBeforeRender, METH_VARARGS, "SoQtRenderArea_setClearBeforeRender(SoQtRenderArea self, SbBool enable, SbBool zbEnable=1)"},
	 { "SoQtRenderArea_isClearBeforeRender", _wrap_SoQtRenderArea_isClearBeforeRender, METH_O, "SoQtRenderArea_isClearBeforeRender(SoQtRenderArea self) -> SbBool"},
	 { "SoQtRenderArea_isClearZBufferBeforeRender", _wrap_SoQtRenderArea_isClearZBufferBeforeRender, METH_O, "SoQtRenderArea_isClearZBufferBeforeRender(SoQtRenderArea self) -> SbBool"},
	 { "SoQtRenderArea_setClearBeforeOverlayRender", _wrap_SoQtRenderArea_setClearBeforeOverlayRender, METH_VARARGS, "SoQtRenderArea_setClearBeforeOverlayRender(SoQtRenderArea self, SbBool enable)"},
	 { "SoQtRenderArea_isClearBeforeOverlayRender", _wrap_SoQtRenderArea_isClearBeforeOverlayRender, METH_O, "SoQtRenderArea_isClearBeforeOverlayRender(SoQtRenderArea self) -> SbBool"},
	 { "SoQtRenderArea_setAutoRedraw", _wrap_SoQtRenderArea_setAutoRedraw, METH_VARARGS, "SoQtRenderArea_setAutoRedraw(SoQtRenderArea self, SbBool enable)"},
	 { "SoQtRenderArea_isAutoRedraw", _wrap_SoQtRenderArea_isAutoRedraw, METH_O, "SoQtRenderArea_isAutoRedraw(SoQtRenderArea self) -> SbBool"},
	 { "SoQtRenderArea_setRedrawPriority", _wrap_SoQtRenderArea_setRedrawPriority, METH_VARARGS, "SoQtRenderArea_setRedrawPriority(SoQtRenderArea self, uint32_t priority)"},
	 { "SoQtRenderArea_getRedrawPriority", _wrap_SoQtRenderArea_getRedrawPriority, METH_O, "SoQtRenderArea_getRedrawPriority(SoQtRenderArea self) -> uint32_t"},
	 { "SoQtRenderArea_getDefaultRedrawPriority", _wrap_SoQtRenderArea_getDefaultRedrawPriority, METH_NOARGS, "SoQtRenderArea_getDefaultRedrawPriority() -> uint32_t"},
	 { "SoQtRenderArea_render", _wrap_SoQtRenderArea_render, METH_O, "SoQtRenderArea_render(SoQtRenderArea self)"},
	 { "SoQtRenderArea_renderOverlay", _wrap_SoQtRenderArea_renderOverlay, METH_O, "SoQtRenderArea_renderOverlay(SoQtRenderArea self)"},
	 { "SoQtRenderArea_scheduleRedraw", _wrap_SoQtRenderArea_scheduleRedraw, METH_O, "SoQtRenderArea_scheduleRedraw(SoQtRenderArea self)"},
	 { "SoQtRenderArea_scheduleOverlayRedraw", _wrap_SoQtRenderArea_scheduleOverlayRedraw, METH_O, "SoQtRenderArea_scheduleOverlayRedraw(SoQtRenderArea self)"},
	 { "SoQtRenderArea_redrawOnSelectionChange", _wrap_SoQtRenderArea_redrawOnSelectionChange, METH_VARARGS, "SoQtRenderArea_redrawOnSelectionChange(SoQtRenderArea self, SoSelection selection)"},
	 { "SoQtRenderArea_redrawOverlayOnSelectionChange", _wrap_SoQtRenderArea_redrawOverlayOnSelectionChange, METH_VARARGS, "SoQtRenderArea_redrawOverlayOnSelectionChange(SoQtRenderArea self, SoSelection selection)"},
	 { "SoQtRenderArea_setSceneManager", _wrap_SoQtRenderArea_setSceneManager, METH_VARARGS, "SoQtRenderArea_setSceneManager(SoQtRenderArea self, SoSceneManager manager)"},
	 { "SoQtRenderArea_getSceneManager", _wrap_SoQtRenderArea_getSceneManager, METH_O, "SoQtRenderArea_getSceneManager(SoQtRenderArea self) -> SoSceneManager"},
	 { "SoQtRenderArea_setOverlaySceneManager", _wrap_SoQtRenderArea_setOverlaySceneManager, METH_VARARGS, "SoQtRenderArea_setOverlaySceneManager(SoQtRenderArea self, SoSceneManager manager)"},
	 { "SoQtRenderArea_getOverlaySceneManager", _wrap_SoQtRenderArea_getOverlaySceneManager, METH_O, "SoQtRenderArea_getOverlaySceneManager(SoQtRenderArea self) -> SoSceneManager"},
	 { "SoQtRenderArea_setGLRenderAction", _wrap_SoQtRenderArea_setGLRenderAction, METH_VARARGS, "SoQtRenderArea_setGLRenderAction(SoQtRenderArea self, SoGLRenderAction action)"},
	 { "SoQtRenderArea_getGLRenderAction", _wrap_SoQtRenderArea_getGLRenderAction, METH_O, "SoQtRenderArea_getGLRenderAction(SoQtRenderArea self) -> SoGLRenderAction"},
	 { "SoQtRenderArea_setOverlayGLRenderAction", _wrap_SoQtRenderArea_setOverlayGLRenderAction, METH_VARARGS, "SoQtRenderArea_setOverlayGLRenderAction(SoQtRenderArea self, SoGLRenderAction action)"},
	 { "SoQtRenderArea_getOverlayGLRenderAction", _wrap_SoQtRenderArea_getOverlayGLRenderAction, METH_O, "SoQtRenderArea_getOverlayGLRenderAction(SoQtRenderArea self) -> SoGLRenderAction"},
	 { "SoQtRenderArea_sendSoEvent", _wrap_SoQtRenderArea_sendSoEvent, METH_VARARGS, "SoQtRenderArea_sendSoEvent(SoQtRenderArea self, SoEvent event) -> SbBool"},
	 { "SoQtRenderArea_registerDevice", _wrap_SoQtRenderArea_registerDevice, METH_VARARGS, "SoQtRenderArea_registerDevice(SoQtRenderArea self, SoQtDevice device)"},
	 { "SoQtRenderArea_unregisterDevice", _wrap_SoQtRenderArea_unregisterDevice, METH_VARARGS, "SoQtRenderArea_unregisterDevice(SoQtRenderArea self, SoQtDevice device)"},
	 { "SoQtRenderArea_setEventCallback", _wrap_SoQtRenderArea_setEventCallback, METH_VARARGS, "\n"
		"SoQtRenderArea_setEventCallback(SoQtRenderArea self, SoQtRenderAreaEventCB * func, void * user=None)\n"
		"SoQtRenderArea_setEventCallback(SoQtRenderArea self, PyObject * pyfunc, PyObject * user=None)\n"
		""},
	 { "SoQtRenderArea_swigregister", SoQtRenderArea_swigregister, METH_O, NULL},
	 { "SoQtRenderArea_swiginit", SoQtRenderArea_swiginit, METH_VARARGS, NULL},
	 { "SoQtViewer_initClass", _wrap_SoQtViewer_initClass, METH_NOARGS, "SoQtViewer_initClass()"},
	 { "SoQtViewer_getClassTypeId", _wrap_SoQtViewer_getClassTypeId, METH_NOARGS, "SoQtViewer_getClassTypeId() -> SoType"},
	 { "SoQtViewer_getTypeId", _wrap_SoQtViewer_getTypeId, METH_O, "SoQtViewer_getTypeId(SoQtViewer self) -> SoType"},
	 { "SoQtViewer_setCamera", _wrap_SoQtViewer_setCamera, METH_VARARGS, "SoQtViewer_setCamera(SoQtViewer self, SoCamera camera)"},
	 { "SoQtViewer_getCamera", _wrap_SoQtViewer_getCamera, METH_O, "SoQtViewer_getCamera(SoQtViewer self) -> SoCamera"},
	 { "SoQtViewer_setCameraType", _wrap_SoQtViewer_setCameraType, METH_VARARGS, "SoQtViewer_setCameraType(SoQtViewer self, SoType type)"},
	 { "SoQtViewer_getCameraType", _wrap_SoQtViewer_getCameraType, METH_O, "SoQtViewer_getCameraType(SoQtViewer self) -> SoType"},
	 { "SoQtViewer_toggleCameraType", _wrap_SoQtViewer_toggleCameraType, METH_O, "SoQtViewer_toggleCameraType(SoQtViewer self)"},
	 { "SoQtViewer_viewAll", _wrap_SoQtViewer_viewAll, METH_O, "SoQtViewer_viewAll(SoQtViewer self)"},
	 { "SoQtViewer_saveHomePosition", _wrap_SoQtViewer_saveHomePosition, METH_O, "SoQtViewer_saveHomePosition(SoQtViewer self)"},
	 { "SoQtViewer_resetToHomePosition", _wrap_SoQtViewer_resetToHomePosition, METH_O, "SoQtViewer_resetToHomePosition(SoQtViewer self)"},
	 { "SoQtViewer_setHeadlight", _wrap_SoQtViewer_setHeadlight, METH_VARARGS, "SoQtViewer_setHeadlight(SoQtViewer self, SbBool enable)"},
	 { "SoQtViewer_isHeadlight", _wrap_SoQtViewer_isHeadlight, METH_O, "SoQtViewer_isHeadlight(SoQtViewer self) -> SbBool"},
	 { "SoQtViewer_getHeadlight", _wrap_SoQtViewer_getHeadlight, METH_O, "SoQtViewer_getHeadlight(SoQtViewer self) -> SoDirectionalLight"},
	 { "SoQtViewer_setDrawStyle", _wrap_SoQtViewer_setDrawStyle, METH_VARARGS, "SoQtViewer_setDrawStyle(SoQtViewer self, SoQtViewer::DrawType type, SoQtViewer::DrawStyle style)"},
	 { "SoQtViewer_getDrawStyle", _wrap_SoQtViewer_getDrawStyle, METH_VARARGS, "SoQtViewer_getDrawStyle(SoQtViewer self, SoQtViewer::DrawType const type) -> SoQtViewer::DrawStyle"},
	 { "SoQtViewer_setBufferingType", _wrap_SoQtViewer_setBufferingType, METH_VARARGS, "SoQtViewer_setBufferingType(SoQtViewer self, SoQtViewer::BufferType type)"},
	 { "SoQtViewer_getBufferingType", _wrap_SoQtViewer_getBufferingType, METH_O, "SoQtViewer_getBufferingType(SoQtViewer self) -> SoQtViewer::BufferType"},
	 { "SoQtViewer_setViewing", _wrap_SoQtViewer_setViewing, METH_VARARGS, "SoQtViewer_setViewing(SoQtViewer self, SbBool enable)"},
	 { "SoQtViewer_isViewing", _wrap_SoQtViewer_isViewing, METH_O, "SoQtViewer_isViewing(SoQtViewer self) -> SbBool"},
	 { "SoQtViewer_setCursorEnabled", _wrap_SoQtViewer_setCursorEnabled, METH_VARARGS, "SoQtViewer_setCursorEnabled(SoQtViewer self, SbBool enable)"},
	 { "SoQtViewer_isCursorEnabled", _wrap_SoQtViewer_isCursorEnabled, METH_O, "SoQtViewer_isCursorEnabled(SoQtViewer self) -> SbBool"},
	 { "SoQtViewer_setAutoClipping", _wrap_SoQtViewer_setAutoClipping, METH_VARARGS, "SoQtViewer_setAutoClipping(SoQtViewer self, SbBool enable)"},
	 { "SoQtViewer_isAutoClipping", _wrap_SoQtViewer_isAutoClipping, METH_O, "SoQtViewer_isAutoClipping(SoQtViewer self) -> SbBool"},
	 { "SoQtViewer_setAutoClippingStrategy", _wrap_SoQtViewer_setAutoClippingStrategy, METH_VARARGS, "SoQtViewer_setAutoClippingStrategy(SoQtViewer self, SoQtViewer::AutoClippingStrategy const strategy, float const value=0.6, SoQtAutoClippingCB * cb=None, void * cbuserdata=None)"},
	 { "SoQtViewer_setStereoViewing", _wrap_SoQtViewer_setStereoViewing, METH_VARARGS, "SoQtViewer_setStereoViewing(SoQtViewer self, SbBool enable)"},
	 { "SoQtViewer_isStereoViewing", _wrap_SoQtViewer_isStereoViewing, METH_O, "SoQtViewer_isStereoViewing(SoQtViewer self) -> SbBool"},
	 { "SoQtViewer_setStereoOffset", _wrap_SoQtViewer_setStereoOffset, METH_VARARGS, "SoQtViewer_setStereoOffset(SoQtViewer self, float const dist)"},
	 { "SoQtViewer_getStereoOffset", _wrap_SoQtViewer_getStereoOffset, METH_O, "SoQtViewer_getStereoOffset(SoQtViewer self) -> float"},
	 { "SoQtViewer_setStereoType", _wrap_SoQtViewer_setStereoType, METH_VARARGS, "SoQtViewer_setStereoType(SoQtViewer self, SoQtViewer::StereoType s) -> SbBool"},
	 { "SoQtViewer_getStereoType", _wrap_SoQtViewer_getStereoType, METH_O, "SoQtViewer_getStereoType(SoQtViewer self) -> SoQtViewer::StereoType"},
	 { "SoQtViewer_setAnaglyphStereoColorMasks", _wrap_SoQtViewer_setAnaglyphStereoColorMasks, METH_VARARGS, "SoQtViewer_setAnaglyphStereoColorMasks(SoQtViewer self, SbBool const [3] left, SbBool const [3] right)"},
	 { "SoQtViewer_getAnaglyphStereoColorMasks", _wrap_SoQtViewer_getAnaglyphStereoColorMasks, METH_VARARGS, "SoQtViewer_getAnaglyphStereoColorMasks(SoQtViewer self, SbBool [3] left, SbBool [3] right)"},
	 { "SoQtViewer_setDetailSeek", _wrap_SoQtViewer_setDetailSeek, METH_VARARGS, "SoQtViewer_setDetailSeek(SoQtViewer self, SbBool const enable)"},
	 { "SoQtViewer_isDetailSeek", _wrap_SoQtViewer_isDetailSeek, METH_O, "SoQtViewer_isDetailSeek(SoQtViewer self) -> SbBool"},
	 { "SoQtViewer_setSeekTime", _wrap_SoQtViewer_setSeekTime, METH_VARARGS, "SoQtViewer_setSeekTime(SoQtViewer self, float const seconds)"},
	 { "SoQtViewer_getSeekTime", _wrap_SoQtViewer_getSeekTime, METH_O, "SoQtViewer_getSeekTime(SoQtViewer self) -> float"},
	 { "SoQtViewer_addStartCallback", _wrap_SoQtViewer_addStartCallback, METH_VARARGS, "SoQtViewer_addStartCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"},
	 { "SoQtViewer_addFinishCallback", _wrap_SoQtViewer_addFinishCallback, METH_VARARGS, "SoQtViewer_addFinishCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"},
	 { "SoQtViewer_removeStartCallback", _wrap_SoQtViewer_removeStartCallback, METH_VARARGS, "SoQtViewer_removeStartCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"},
	 { "SoQtViewer_removeFinishCallback", _wrap_SoQtViewer_removeFinishCallback, METH_VARARGS, "SoQtViewer_removeFinishCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"},
	 { "SoQtViewer_setWireframeOverlayColor", _wrap_SoQtViewer_setWireframeOverlayColor, METH_VARARGS, "SoQtViewer_setWireframeOverlayColor(SoQtViewer self, SbColor color)"},
	 { "SoQtViewer_getWireframeOverlayColor", _wrap_SoQtViewer_getWireframeOverlayColor, METH_O, "SoQtViewer_getWireframeOverlayColor(SoQtViewer self) -> SbColor"},
	 { "SoQtViewer_setDoubleBuffer", _wrap_SoQtViewer_setDoubleBuffer, METH_VARARGS, "SoQtViewer_setDoubleBuffer(SoQtViewer self, SbBool const enable)"},
	 { "SoQtViewer_setSceneGraph", _wrap_SoQtViewer_setSceneGraph, METH_VARARGS, "SoQtViewer_setSceneGraph(SoQtViewer self, SoNode root)"},
	 { "SoQtViewer_getSceneGraph", _wrap_SoQtViewer_getSceneGraph, METH_O, "SoQtViewer_getSceneGraph(SoQtViewer self) -> SoNode"},
	 { "SoQtViewer_swigregister", SoQtViewer_swigregister, METH_O, NULL},
	 { "SoQtFullViewer_initClass", _wrap_SoQtFullViewer_initClass, METH_NOARGS, "SoQtFullViewer_initClass()"},
	 { "SoQtFullViewer_getClassTypeId", _wrap_SoQtFullViewer_getClassTypeId, METH_NOARGS, "SoQtFullViewer_getClassTypeId() -> SoType"},
	 { "SoQtFullViewer_getTypeId", _wrap_SoQtFullViewer_getTypeId, METH_O, "SoQtFullViewer_getTypeId(SoQtFullViewer self) -> SoType"},
	 { "SoQtFullViewer_setDecoration", _wrap_SoQtFullViewer_setDecoration, METH_VARARGS, "SoQtFullViewer_setDecoration(SoQtFullViewer self, SbBool const on)"},
	 { "SoQtFullViewer_isDecoration", _wrap_SoQtFullViewer_isDecoration, METH_O, "SoQtFullViewer_isDecoration(SoQtFullViewer self) -> SbBool"},
	 { "SoQtFullViewer_setPopupMenuEnabled", _wrap_SoQtFullViewer_setPopupMenuEnabled, METH_VARARGS, "SoQtFullViewer_setPopupMenuEnabled(SoQtFullViewer self, SbBool const on)"},
	 { "SoQtFullViewer_isPopupMenuEnabled", _wrap_SoQtFullViewer_isPopupMenuEnabled, METH_O, "SoQtFullViewer_isPopupMenuEnabled(SoQtFullViewer self) -> SbBool"},
	 { "SoQtFullViewer_getAppPushButtonParent", _wrap_SoQtFullViewer_getAppPushButtonParent, METH_O, "SoQtFullViewer_getAppPushButtonParent(SoQtFullViewer self) -> QWidget"},
	 { "SoQtFullViewer_addAppPushButton", _wrap_SoQtFullViewer_addAppPushButton, METH_VARARGS, "SoQtFullViewer_addAppPushButton(SoQtFullViewer self, QWidget newButton)"},
	 { "SoQtFullViewer_insertAppPushButton", _wrap_SoQtFullViewer_insertAppPushButton, METH_VARARGS, "SoQtFullViewer_insertAppPushButton(SoQtFullViewer self, QWidget newButton, int index)"},
	 { "SoQtFullViewer_removeAppPushButton", _wrap_SoQtFullViewer_removeAppPushButton, METH_VARARGS, "SoQtFullViewer_removeAppPushButton(SoQtFullViewer self, QWidget oldButton)"},
	 { "SoQtFullViewer_findAppPushButton", _wrap_SoQtFullViewer_findAppPushButton, METH_VARARGS, "SoQtFullViewer_findAppPushButton(SoQtFullViewer self, QWidget oldButton) -> int"},
	 { "SoQtFullViewer_lengthAppPushButton", _wrap_SoQtFullViewer_lengthAppPushButton, METH_O, "SoQtFullViewer_lengthAppPushButton(SoQtFullViewer self) -> int"},
	 { "SoQtFullViewer_getRenderAreaWidget", _wrap_SoQtFullViewer_getRenderAreaWidget, METH_O, "SoQtFullViewer_getRenderAreaWidget(SoQtFullViewer self) -> QWidget"},
	 { "SoQtFullViewer_setViewing", _wrap_SoQtFullViewer_setViewing, METH_VARARGS, "SoQtFullViewer_setViewing(SoQtFullViewer self, SbBool on)"},
	 { "SoQtFullViewer_setComponentCursor", _wrap_SoQtFullViewer_setComponentCursor, METH_VARARGS, "SoQtFullViewer_setComponentCursor(SoQtFullViewer self, SoQtCursor cursor)"},
	 { "SoQtFullViewer_swigregister", SoQtFullViewer_swigregister, METH_O, NULL},
	 { "SoQtPlaneViewer_initClass", _wrap_SoQtPlaneViewer_initClass, METH_NOARGS, "SoQtPlaneViewer_initClass()"},
	 { "SoQtPlaneViewer_getClassTypeId", _wrap_SoQtPlaneViewer_getClassTypeId, METH_NOARGS, "SoQtPlaneViewer_getClassTypeId() -> SoType"},
	 { "SoQtPlaneViewer_getTypeId", _wrap_SoQtPlaneViewer_getTypeId, METH_O, "SoQtPlaneViewer_getTypeId(SoQtPlaneViewer self) -> SoType"},
	 { "SoQtPlaneViewer_createInstance", _wrap_SoQtPlaneViewer_createInstance, METH_NOARGS, "SoQtPlaneViewer_createInstance() -> void *"},
	 { "new_SoQtPlaneViewer", _wrap_new_SoQtPlaneViewer, METH_VARARGS, "SoQtPlaneViewer(QWidget parent=None, char const *const name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER)"},
	 { "delete_SoQtPlaneViewer", _wrap_delete_SoQtPlaneViewer, METH_O, "delete_SoQtPlaneViewer(SoQtPlaneViewer self)"},
	 { "SoQtPlaneViewer_setViewing", _wrap_SoQtPlaneViewer_setViewing, METH_VARARGS, "SoQtPlaneViewer_setViewing(SoQtPlaneViewer self, SbBool enable)"},
	 { "SoQtPlaneViewer_setCamera", _wrap_SoQtPlaneViewer_setCamera, METH_VARARGS, "SoQtPlaneViewer_setCamera(SoQtPlaneViewer self, SoCamera camera)"},
	 { "SoQtPlaneViewer_setCursorEnabled", _wrap_SoQtPlaneViewer_setCursorEnabled, METH_VARARGS, "SoQtPlaneViewer_setCursorEnabled(SoQtPlaneViewer self, SbBool enable)"},
	 { "SoQtPlaneViewer_swigregister", SoQtPlaneViewer_swigregister, METH_O, NULL},
	 { "SoQtPlaneViewer_swiginit", SoQtPlaneViewer_swiginit, METH_VARARGS, NULL},
	 { "SoQtExaminerViewer_initClass", _wrap_SoQtExaminerViewer_initClass, METH_NOARGS, "SoQtExaminerViewer_initClass()"},
	 { "SoQtExaminerViewer_getClassTypeId", _wrap_SoQtExaminerViewer_getClassTypeId, METH_NOARGS, "SoQtExaminerViewer_getClassTypeId() -> SoType"},
	 { "SoQtExaminerViewer_getTypeId", _wrap_SoQtExaminerViewer_getTypeId, METH_O, "SoQtExaminerViewer_getTypeId(SoQtExaminerViewer self) -> SoType"},
	 { "SoQtExaminerViewer_createInstance", _wrap_SoQtExaminerViewer_createInstance, METH_NOARGS, "SoQtExaminerViewer_createInstance() -> void *"},
	 { "new_SoQtExaminerViewer", _wrap_new_SoQtExaminerViewer, METH_VARARGS, "SoQtExaminerViewer(QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER)"},
	 { "delete_SoQtExaminerViewer", _wrap_delete_SoQtExaminerViewer, METH_O, "delete_SoQtExaminerViewer(SoQtExaminerViewer self)"},
	 { "SoQtExaminerViewer_setAnimationEnabled", _wrap_SoQtExaminerViewer_setAnimationEnabled, METH_VARARGS, "SoQtExaminerViewer_setAnimationEnabled(SoQtExaminerViewer self, SbBool const enable)"},
	 { "SoQtExaminerViewer_isAnimationEnabled", _wrap_SoQtExaminerViewer_isAnimationEnabled, METH_O, "SoQtExaminerViewer_isAnimationEnabled(SoQtExaminerViewer self) -> SbBool"},
	 { "SoQtExaminerViewer_stopAnimating", _wrap_SoQtExaminerViewer_stopAnimating, METH_O, "SoQtExaminerViewer_stopAnimating(SoQtExaminerViewer self)"},
	 { "SoQtExaminerViewer_isAnimating", _wrap_SoQtExaminerViewer_isAnimating, METH_O, "SoQtExaminerViewer_isAnimating(SoQtExaminerViewer self) -> SbBool"},
	 { "SoQtExaminerViewer_setFeedbackVisibility", _wrap_SoQtExaminerViewer_setFeedbackVisibility, METH_VARARGS, "SoQtExaminerViewer_setFeedbackVisibility(SoQtExaminerViewer self, SbBool const enable)"},
	 { "SoQtExaminerViewer_isFeedbackVisible", _wrap_SoQtExaminerViewer_isFeedbackVisible, METH_O, "SoQtExaminerViewer_isFeedbackVisible(SoQtExaminerViewer self) -> SbBool"},
	 { "SoQtExaminerViewer_setFeedbackSize", _wrap_SoQtExaminerViewer_setFeedbackSize, METH_VARARGS, "SoQtExaminerViewer_setFeedbackSize(SoQtExaminerViewer self, int const size)"},
	 { "SoQtExaminerViewer_getFeedbackSize", _wrap_SoQtExaminerViewer_getFeedbackSize, METH_O, "SoQtExaminerViewer_getFeedbackSize(SoQtExaminerViewer self) -> int"},
	 { "SoQtExaminerViewer_setViewing", _wrap_SoQtExaminerViewer_setViewing, METH_VARARGS, "SoQtExaminerViewer_setViewing(SoQtExaminerViewer self, SbBool enable)"},
	 { "SoQtExaminerViewer_setCamera", _wrap_SoQtExaminerViewer_setCamera, METH_VARARGS, "SoQtExaminerViewer_setCamera(SoQtExaminerViewer self, SoCamera camera)"},
	 { "SoQtExaminerViewer_setCursorEnabled", _wrap_SoQtExaminerViewer_setCursorEnabled, METH_VARARGS, "SoQtExaminerViewer_setCursorEnabled(SoQtExaminerViewer self, SbBool enable)"},
	 { "SoQtExaminerViewer_swigregister", SoQtExaminerViewer_swigregister, METH_O, NULL},
	 { "SoQtExaminerViewer_swiginit", SoQtExaminerViewer_swiginit, METH_VARARGS, NULL},
	 { "SoQtConstrainedViewer_initClass", _wrap_SoQtConstrainedViewer_initClass, METH_NOARGS, "SoQtConstrainedViewer_initClass()"},
	 { "SoQtConstrainedViewer_getClassTypeId", _wrap_SoQtConstrainedViewer_getClassTypeId, METH_NOARGS, "SoQtConstrainedViewer_getClassTypeId() -> SoType"},
	 { "SoQtConstrainedViewer_getTypeId", _wrap_SoQtConstrainedViewer_getTypeId, METH_O, "SoQtConstrainedViewer_getTypeId(SoQtConstrainedViewer self) -> SoType"},
	 { "SoQtConstrainedViewer_setUpDirection", _wrap_SoQtConstrainedViewer_setUpDirection, METH_VARARGS, "SoQtConstrainedViewer_setUpDirection(SoQtConstrainedViewer self, SbVec3f dir)"},
	 { "SoQtConstrainedViewer_getUpDirection", _wrap_SoQtConstrainedViewer_getUpDirection, METH_O, "SoQtConstrainedViewer_getUpDirection(SoQtConstrainedViewer self) -> SbVec3f"},
	 { "SoQtConstrainedViewer_setCamera", _wrap_SoQtConstrainedViewer_setCamera, METH_VARARGS, "SoQtConstrainedViewer_setCamera(SoQtConstrainedViewer self, SoCamera newcam)"},
	 { "SoQtConstrainedViewer_saveHomePosition", _wrap_SoQtConstrainedViewer_saveHomePosition, METH_O, "SoQtConstrainedViewer_saveHomePosition(SoQtConstrainedViewer self)"},
	 { "SoQtConstrainedViewer_resetToHomePosition", _wrap_SoQtConstrainedViewer_resetToHomePosition, METH_O, "SoQtConstrainedViewer_resetToHomePosition(SoQtConstrainedViewer self)"},
	 { "SoQtConstrainedViewer_swigregister", SoQtConstrainedViewer_swigregister, METH_O, NULL},
	 { "SoQtFlyViewer_initClass", _wrap_SoQtFlyViewer_initClass, METH_NOARGS, "SoQtFlyViewer_initClass()"},
	 { "SoQtFlyViewer_getClassTypeId", _wrap_SoQtFlyViewer_getClassTypeId, METH_NOARGS, "SoQtFlyViewer_getClassTypeId() -> SoType"},
	 { "SoQtFlyViewer_getTypeId", _wrap_SoQtFlyViewer_getTypeId, METH_O, "SoQtFlyViewer_getTypeId(SoQtFlyViewer self) -> SoType"},
	 { "SoQtFlyViewer_createInstance", _wrap_SoQtFlyViewer_createInstance, METH_NOARGS, "SoQtFlyViewer_createInstance() -> void *"},
	 { "new_SoQtFlyViewer", _wrap_new_SoQtFlyViewer, METH_VARARGS, "SoQtFlyViewer(QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER)"},
	 { "delete_SoQtFlyViewer", _wrap_delete_SoQtFlyViewer, METH_O, "delete_SoQtFlyViewer(SoQtFlyViewer self)"},
	 { "SoQtFlyViewer_setViewing", _wrap_SoQtFlyViewer_setViewing, METH_VARARGS, "SoQtFlyViewer_setViewing(SoQtFlyViewer self, SbBool enable)"},
	 { "SoQtFlyViewer_viewAll", _wrap_SoQtFlyViewer_viewAll, METH_O, "SoQtFlyViewer_viewAll(SoQtFlyViewer self)"},
	 { "SoQtFlyViewer_resetToHomePosition", _wrap_SoQtFlyViewer_resetToHomePosition, METH_O, "SoQtFlyViewer_resetToHomePosition(SoQtFlyViewer self)"},
	 { "SoQtFlyViewer_setCamera", _wrap_SoQtFlyViewer_setCamera, METH_VARARGS, "SoQtFlyViewer_setCamera(SoQtFlyViewer self, SoCamera camera)"},
	 { "SoQtFlyViewer_setCursorEnabled", _wrap_SoQtFlyViewer_setCursorEnabled, METH_VARARGS, "SoQtFlyViewer_setCursorEnabled(SoQtFlyViewer self, SbBool enable)"},
	 { "SoQtFlyViewer_setCameraType", _wrap_SoQtFlyViewer_setCameraType, METH_VARARGS, "SoQtFlyViewer_setCameraType(SoQtFlyViewer self, SoType type)"},
	 { "SoQtFlyViewer_swigregister", SoQtFlyViewer_swigregister, METH_O, NULL},
	 { "SoQtFlyViewer_swiginit", SoQtFlyViewer_swiginit, METH_VARARGS, NULL},
	 { "SoQtPopupMenu_createInstance", _wrap_SoQtPopupMenu_createInstance, METH_NOARGS, "SoQtPopupMenu_createInstance() -> SoQtPopupMenu"},
	 { "delete_SoQtPopupMenu", _wrap_delete_SoQtPopupMenu, METH_O, "delete_SoQtPopupMenu(SoQtPopupMenu self)"},
	 { "SoQtPopupMenu_newMenu", _wrap_SoQtPopupMenu_newMenu, METH_VARARGS, "SoQtPopupMenu_newMenu(SoQtPopupMenu self, char const * name, int menuid=-1) -> int"},
	 { "SoQtPopupMenu_getMenu", _wrap_SoQtPopupMenu_getMenu, METH_VARARGS, "SoQtPopupMenu_getMenu(SoQtPopupMenu self, char const * name) -> int"},
	 { "SoQtPopupMenu_setMenuTitle", _wrap_SoQtPopupMenu_setMenuTitle, METH_VARARGS, "SoQtPopupMenu_setMenuTitle(SoQtPopupMenu self, int id, char const * title)"},
	 { "SoQtPopupMenu_getMenuTitle", _wrap_SoQtPopupMenu_getMenuTitle, METH_VARARGS, "SoQtPopupMenu_getMenuTitle(SoQtPopupMenu self, int id) -> char const *"},
	 { "SoQtPopupMenu_newMenuItem", _wrap_SoQtPopupMenu_newMenuItem, METH_VARARGS, "SoQtPopupMenu_newMenuItem(SoQtPopupMenu self, char const * name, int itemid=-1) -> int"},
	 { "SoQtPopupMenu_getMenuItem", _wrap_SoQtPopupMenu_getMenuItem, METH_VARARGS, "SoQtPopupMenu_getMenuItem(SoQtPopupMenu self, char const * name) -> int"},
	 { "SoQtPopupMenu_setMenuItemTitle", _wrap_SoQtPopupMenu_setMenuItemTitle, METH_VARARGS, "SoQtPopupMenu_setMenuItemTitle(SoQtPopupMenu self, int itemid, char const * title)"},
	 { "SoQtPopupMenu_getMenuItemTitle", _wrap_SoQtPopupMenu_getMenuItemTitle, METH_VARARGS, "SoQtPopupMenu_getMenuItemTitle(SoQtPopupMenu self, int itemid) -> char const *"},
	 { "SoQtPopupMenu_setMenuItemEnabled", _wrap_SoQtPopupMenu_setMenuItemEnabled, METH_VARARGS, "SoQtPopupMenu_setMenuItemEnabled(SoQtPopupMenu self, int itemid, SbBool enabled)"},
	 { "SoQtPopupMenu_getMenuItemEnabled", _wrap_SoQtPopupMenu_getMenuItemEnabled, METH_VARARGS, "SoQtPopupMenu_getMenuItemEnabled(SoQtPopupMenu self, int itemid) -> SbBool"},
	 { "SoQtPopupMenu_setMenuItemMarked", _wrap_SoQtPopupMenu_setMenuItemMarked, METH_VARARGS, "SoQtPopupMenu_setMenuItemMarked(SoQtPopupMenu self, int itemid, SbBool marked)"},
	 { "SoQtPopupMenu_getMenuItemMarked", _wrap_SoQtPopupMenu_getMenuItemMarked, METH_VARARGS, "SoQtPopupMenu_getMenuItemMarked(SoQtPopupMenu self, int itemid) -> SbBool"},
	 { "SoQtPopupMenu_addMenu", _wrap_SoQtPopupMenu_addMenu, METH_VARARGS, "SoQtPopupMenu_addMenu(SoQtPopupMenu self, int menuid, int submenuid, int pos=-1)"},
	 { "SoQtPopupMenu_addMenuItem", _wrap_SoQtPopupMenu_addMenuItem, METH_VARARGS, "SoQtPopupMenu_addMenuItem(SoQtPopupMenu self, int menuid, int itemid, int pos=-1)"},
	 { "SoQtPopupMenu_addSeparator", _wrap_SoQtPopupMenu_addSeparator, METH_VARARGS, "SoQtPopupMenu_addSeparator(SoQtPopupMenu self, int menuid, int pos=-1)"},
	 { "SoQtPopupMenu_removeMenu", _wrap_SoQtPopupMenu_removeMenu, METH_VARARGS, "SoQtPopupMenu_removeMenu(SoQtPopupMenu self, int menuid)"},
	 { "SoQtPopupMenu_removeMenuItem", _wrap_SoQtPopupMenu_removeMenuItem, METH_VARARGS, "SoQtPopupMenu_removeMenuItem(SoQtPopupMenu self, int itemid)"},
	 { "SoQtPopupMenu_popUp", _wrap_SoQtPopupMenu_popUp, METH_VARARGS, "SoQtPopupMenu_popUp(SoQtPopupMenu self, QWidget inside, int x, int y)"},
	 { "SoQtPopupMenu_newRadioGroup", _wrap_SoQtPopupMenu_newRadioGroup, METH_VARARGS, "SoQtPopupMenu_newRadioGroup(SoQtPopupMenu self, int groupid=-1) -> int"},
	 { "SoQtPopupMenu_getRadioGroup", _wrap_SoQtPopupMenu_getRadioGroup, METH_VARARGS, "SoQtPopupMenu_getRadioGroup(SoQtPopupMenu self, int itemid) -> int"},
	 { "SoQtPopupMenu_getRadioGroupSize", _wrap_SoQtPopupMenu_getRadioGroupSize, METH_VARARGS, "SoQtPopupMenu_getRadioGroupSize(SoQtPopupMenu self, int groupid) -> int"},
	 { "SoQtPopupMenu_addRadioGroupItem", _wrap_SoQtPopupMenu_addRadioGroupItem, METH_VARARGS, "SoQtPopupMenu_addRadioGroupItem(SoQtPopupMenu self, int groupid, int itemid)"},
	 { "SoQtPopupMenu_removeRadioGroupItem", _wrap_SoQtPopupMenu_removeRadioGroupItem, METH_VARARGS, "SoQtPopupMenu_removeRadioGroupItem(SoQtPopupMenu self, int itemid)"},
	 { "SoQtPopupMenu_setRadioGroupMarkedItem", _wrap_SoQtPopupMenu_setRadioGroupMarkedItem, METH_VARARGS, "SoQtPopupMenu_setRadioGroupMarkedItem(SoQtPopupMenu self, int itemid)"},
	 { "SoQtPopupMenu_getRadioGroupMarkedItem", _wrap_SoQtPopupMenu_getRadioGroupMarkedItem, METH_VARARGS, "SoQtPopupMenu_getRadioGroupMarkedItem(SoQtPopupMenu self, int groupid) -> int"},
	 { "SoQtPopupMenu_addMenuSelectionCallback", _wrap_SoQtPopupMenu_addMenuSelectionCallback, METH_VARARGS, "SoQtPopupMenu_addMenuSelectionCallback(SoQtPopupMenu self, SoQtMenuSelectionCallback * callback, void * data)"},
	 { "SoQtPopupMenu_removeMenuSelectionCallback", _wrap_SoQtPopupMenu_removeMenuSelectionCallback, METH_VARARGS, "SoQtPopupMenu_removeMenuSelectionCallback(SoQtPopupMenu self, SoQtMenuSelectionCallback * callback, void * data)"},
	 { "SoQtPopupMenu_swigregister", SoQtPopupMenu_swigregister, METH_O, NULL},
	 { "SoQtCursor_initClass", _wrap_SoQtCursor_initClass, METH_NOARGS, "SoQtCursor_initClass()"},
	 { "new_SoQtCursor", _wrap_new_SoQtCursor, METH_VARARGS, "\n"
		"SoQtCursor()\n"
		"SoQtCursor(SoQtCursor::Shape const shape)\n"
		"SoQtCursor(SoQtCursor::CustomCursor const * cc)\n"
		"new_SoQtCursor(SoQtCursor cursor) -> SoQtCursor\n"
		""},
	 { "delete_SoQtCursor", _wrap_delete_SoQtCursor, METH_O, "delete_SoQtCursor(SoQtCursor self)"},
	 { "SoQtCursor_getShape", _wrap_SoQtCursor_getShape, METH_O, "SoQtCursor_getShape(SoQtCursor self) -> SoQtCursor::Shape"},
	 { "SoQtCursor_setShape", _wrap_SoQtCursor_setShape, METH_VARARGS, "SoQtCursor_setShape(SoQtCursor self, SoQtCursor::Shape const shape)"},
	 { "SoQtCursor_getCustomCursor", _wrap_SoQtCursor_getCustomCursor, METH_O, "SoQtCursor_getCustomCursor(SoQtCursor self) -> SoQtCursor::CustomCursor const &"},
	 { "SoQtCursor_getZoomCursor", _wrap_SoQtCursor_getZoomCursor, METH_NOARGS, "SoQtCursor_getZoomCursor() -> SoQtCursor"},
	 { "SoQtCursor_getPanCursor", _wrap_SoQtCursor_getPanCursor, METH_NOARGS, "SoQtCursor_getPanCursor() -> SoQtCursor"},
	 { "SoQtCursor_getRotateCursor", _wrap_SoQtCursor_getRotateCursor, METH_NOARGS, "SoQtCursor_getRotateCursor() -> SoQtCursor"},
	 { "SoQtCursor_getBlankCursor", _wrap_SoQtCursor_getBlankCursor, METH_NOARGS, "SoQtCursor_getBlankCursor() -> SoQtCursor"},
	 { "SoQtCursor_swigregister", SoQtCursor_swigregister, METH_O, NULL},
	 { "SoQtCursor_swiginit", SoQtCursor_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_intpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((intp *) 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_SbColorTo_p_SbVec3f(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbVec3f *)  ((SbColor *) x));
}
static void *_p_SbColor4fTo_p_SbVec4f(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SbVec4f *)  ((SbColor4f *) 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_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_SoDirectionalLightManipTo_p_SoDirectionalLight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoDirectionalLight *)  ((SoDirectionalLightManip *) 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_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_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_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_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_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_SoQtConstrainedViewerTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *) (SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtConstrainedViewer *) x));
}
static void *_p_SoQtExaminerViewerTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *) (SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtExaminerViewer *) x));
}
static void *_p_SoQtFlyViewerTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *) (SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *)(SoQtConstrainedViewer *) ((SoQtFlyViewer *) x));
}
static void *_p_SoQtFullViewerTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *) (SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *) ((SoQtFullViewer *) x));
}
static void *_p_SoQtGLWidgetTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *)  ((SoQtGLWidget *) x));
}
static void *_p_SoQtPlaneViewerTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *) (SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtPlaneViewer *) x));
}
static void *_p_SoQtRenderAreaTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *) (SoQtGLWidget *) ((SoQtRenderArea *) x));
}
static void *_p_SoQtViewerTo_p_SoQtComponent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtComponent *) (SoQtGLWidget *)(SoQtRenderArea *) ((SoQtViewer *) x));
}
static void *_p_SoQtFlyViewerTo_p_SoQtConstrainedViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtConstrainedViewer *)  ((SoQtFlyViewer *) x));
}
static void *_p_SoQtKeyboardTo_p_SoQtDevice(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtDevice *)  ((SoQtKeyboard *) x));
}
static void *_p_SoQtMouseTo_p_SoQtDevice(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtDevice *)  ((SoQtMouse *) x));
}
static void *_p_SoQtConstrainedViewerTo_p_SoQtFullViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtFullViewer *)  ((SoQtConstrainedViewer *) x));
}
static void *_p_SoQtExaminerViewerTo_p_SoQtFullViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtFullViewer *)  ((SoQtExaminerViewer *) x));
}
static void *_p_SoQtFlyViewerTo_p_SoQtFullViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtFullViewer *) (SoQtConstrainedViewer *) ((SoQtFlyViewer *) x));
}
static void *_p_SoQtPlaneViewerTo_p_SoQtFullViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtFullViewer *)  ((SoQtPlaneViewer *) x));
}
static void *_p_SoQtConstrainedViewerTo_p_SoQtGLWidget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtGLWidget *) (SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtConstrainedViewer *) x));
}
static void *_p_SoQtExaminerViewerTo_p_SoQtGLWidget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtGLWidget *) (SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtExaminerViewer *) x));
}
static void *_p_SoQtFlyViewerTo_p_SoQtGLWidget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtGLWidget *) (SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *)(SoQtConstrainedViewer *) ((SoQtFlyViewer *) x));
}
static void *_p_SoQtFullViewerTo_p_SoQtGLWidget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtGLWidget *) (SoQtRenderArea *)(SoQtViewer *) ((SoQtFullViewer *) x));
}
static void *_p_SoQtPlaneViewerTo_p_SoQtGLWidget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtGLWidget *) (SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtPlaneViewer *) x));
}
static void *_p_SoQtRenderAreaTo_p_SoQtGLWidget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtGLWidget *)  ((SoQtRenderArea *) x));
}
static void *_p_SoQtViewerTo_p_SoQtGLWidget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtGLWidget *) (SoQtRenderArea *) ((SoQtViewer *) x));
}
static void *_p_SoQtComponentTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *)  ((SoQtComponent *) x));
}
static void *_p_SoQtConstrainedViewerTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *)(SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtConstrainedViewer *) x));
}
static void *_p_SoQtDeviceTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *)  ((SoQtDevice *) x));
}
static void *_p_SoQtExaminerViewerTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *)(SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtExaminerViewer *) x));
}
static void *_p_SoQtFlyViewerTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *)(SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *)(SoQtConstrainedViewer *) ((SoQtFlyViewer *) x));
}
static void *_p_SoQtFullViewerTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *)(SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *) ((SoQtFullViewer *) x));
}
static void *_p_SoQtGLWidgetTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *) ((SoQtGLWidget *) x));
}
static void *_p_SoQtKeyboardTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtDevice *) ((SoQtKeyboard *) x));
}
static void *_p_SoQtMouseTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtDevice *) ((SoQtMouse *) x));
}
static void *_p_SoQtPlaneViewerTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *)(SoQtGLWidget *)(SoQtRenderArea *)(SoQtViewer *)(SoQtFullViewer *) ((SoQtPlaneViewer *) x));
}
static void *_p_SoQtRenderAreaTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *)(SoQtGLWidget *) ((SoQtRenderArea *) x));
}
static void *_p_SoQtViewerTo_p_SoQtObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtObject *) (SoQtComponent *)(SoQtGLWidget *)(SoQtRenderArea *) ((SoQtViewer *) x));
}
static void *_p_SoQtConstrainedViewerTo_p_SoQtRenderArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtRenderArea *) (SoQtViewer *)(SoQtFullViewer *) ((SoQtConstrainedViewer *) x));
}
static void *_p_SoQtExaminerViewerTo_p_SoQtRenderArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtRenderArea *) (SoQtViewer *)(SoQtFullViewer *) ((SoQtExaminerViewer *) x));
}
static void *_p_SoQtFlyViewerTo_p_SoQtRenderArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtRenderArea *) (SoQtViewer *)(SoQtFullViewer *)(SoQtConstrainedViewer *) ((SoQtFlyViewer *) x));
}
static void *_p_SoQtFullViewerTo_p_SoQtRenderArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtRenderArea *) (SoQtViewer *) ((SoQtFullViewer *) x));
}
static void *_p_SoQtPlaneViewerTo_p_SoQtRenderArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtRenderArea *) (SoQtViewer *)(SoQtFullViewer *) ((SoQtPlaneViewer *) x));
}
static void *_p_SoQtViewerTo_p_SoQtRenderArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtRenderArea *)  ((SoQtViewer *) x));
}
static void *_p_SoQtConstrainedViewerTo_p_SoQtViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtViewer *) (SoQtFullViewer *) ((SoQtConstrainedViewer *) x));
}
static void *_p_SoQtExaminerViewerTo_p_SoQtViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtViewer *) (SoQtFullViewer *) ((SoQtExaminerViewer *) x));
}
static void *_p_SoQtFlyViewerTo_p_SoQtViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtViewer *) (SoQtFullViewer *)(SoQtConstrainedViewer *) ((SoQtFlyViewer *) x));
}
static void *_p_SoQtFullViewerTo_p_SoQtViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtViewer *)  ((SoQtFullViewer *) x));
}
static void *_p_SoQtPlaneViewerTo_p_SoQtViewer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoQtViewer *) (SoQtFullViewer *) ((SoQtPlaneViewer *) 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_SoExtSelectionTo_p_SoSelection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SoSelection *)  ((SoExtSelection *) 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_doublepTo_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double *)  ((doublep *) 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_p_void_p_QEvent__intpTo_p_f_p_void_p_QEvent__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)(void *,QEvent *))  ((intp (*)(void *,QEvent *)) 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_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__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_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_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_floatpTo_p_float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float *)  ((floatp *) x));
}
static void *_p_longpTo_p_long(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((long *)  ((longp *) 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_charpTo_p_p_char(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((char **)  ((charp **) 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_FatalErrorCB = {"_p_FatalErrorCB", "FatalErrorCB *", 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_QEvent = {"_p_QEvent", "QEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QWidget = {"_p_QWidget", "QWidget *", 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_SbDPMatrix = {"_p_SbDPMatrix", "SbMatrixd *|SbDPMatrix *", 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_SbDict = {"_p_SbDict", "SbDict *", 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_SbIntList = {"_p_SbIntList", "SbIntList *", 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_SbName = {"_p_SbName", "SbName *", 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_SbStringList = {"_p_SbStringList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SbVec3fList = {"_p_SbVec3fList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoActionMethodList = {"_p_SoActionMethodList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoAuditorList = {"_p_SoAuditorList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBaseList = {"_p_SoBaseList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoChildList = {"_p_SoChildList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDetailList = {"_p_SoDetailList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoEngineList = {"_p_SoEngineList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoEngineOutputList = {"_p_SoEngineOutputList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNodeList = {"_p_SoNodeList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPathList = {"_p_SoPathList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPickedPointList = {"_p_SoPickedPointList", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SbPlane = {"_p_SbPlane", "SbPlane *", 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_SbString = {"_p_SbString", "SbString *", 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_SbVec2us = {"_p_SbVec2us", "SbVec2us *", 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_SbVec4f = {"_p_SbVec4f", "SbVec4f *", 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_SoBase = {"_p_SoBase", "SoBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoAlphaTest = {"_p_SoAlphaTest", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoAnnotation = {"_p_SoAnnotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoAntiSquish = {"_p_SoAntiSquish", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoAppearanceKit = {"_p_SoAppearanceKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoArray = {"_p_SoArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoAsciiText = {"_p_SoAsciiText", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBaseColor = {"_p_SoBaseColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBaseKit = {"_p_SoBaseKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBlinker = {"_p_SoBlinker", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBoolOperation = {"_p_SoBoolOperation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBumpMap = {"_p_SoBumpMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBumpMapCoordinate = {"_p_SoBumpMapCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoBumpMapTransform = {"_p_SoBumpMapTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCacheHint = {"_p_SoCacheHint", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCalculator = {"_p_SoCalculator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCallback = {"_p_SoCallback", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCameraKit = {"_p_SoCameraKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCenterballDragger = {"_p_SoCenterballDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCenterballManip = {"_p_SoCenterballManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoClipPlane = {"_p_SoClipPlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoClipPlaneManip = {"_p_SoClipPlaneManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoColorIndex = {"_p_SoColorIndex", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComplexity = {"_p_SoComplexity", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComposeMatrix = {"_p_SoComposeMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComposeRotation = {"_p_SoComposeRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComposeRotationFromTo = {"_p_SoComposeRotationFromTo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComposeVec2f = {"_p_SoComposeVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComposeVec3f = {"_p_SoComposeVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComposeVec4f = {"_p_SoComposeVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoComputeBoundingBox = {"_p_SoComputeBoundingBox", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoConcatenate = {"_p_SoConcatenate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCone = {"_p_SoCone", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCoordinate3 = {"_p_SoCoordinate3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCoordinate4 = {"_p_SoCoordinate4", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCounter = {"_p_SoCounter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCube = {"_p_SoCube", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCylinder = {"_p_SoCylinder", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDecomposeMatrix = {"_p_SoDecomposeMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDecomposeRotation = {"_p_SoDecomposeRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDecomposeVec2f = {"_p_SoDecomposeVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDecomposeVec3f = {"_p_SoDecomposeVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDecomposeVec4f = {"_p_SoDecomposeVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDepthBuffer = {"_p_SoDepthBuffer", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDirectionalLightDragger = {"_p_SoDirectionalLightDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDirectionalLightManip = {"_p_SoDirectionalLightManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDragPointDragger = {"_p_SoDragPointDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDragger = {"_p_SoDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoDrawStyle = {"_p_SoDrawStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoElapsedTime = {"_p_SoElapsedTime", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoEnvironment = {"_p_SoEnvironment", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoEventCallback = {"_p_SoEventCallback", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoExtSelection = {"_p_SoExtSelection", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFaceSet = {"_p_SoFaceSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFieldConverter = {"_p_SoFieldConverter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFile = {"_p_SoFile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFont = {"_p_SoFont", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFontStyle = {"_p_SoFontStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFragmentShader = {"_p_SoFragmentShader", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFrustumCamera = {"_p_SoFrustumCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFullPath = {"_p_SoFullPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoGate = {"_p_SoGate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoGeoCoordinate = {"_p_SoGeoCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoGeoLocation = {"_p_SoGeoLocation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoGeoOrigin = {"_p_SoGeoOrigin", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoGeoSeparator = {"_p_SoGeoSeparator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoGroup = {"_p_SoGroup", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoHandleBoxDragger = {"_p_SoHandleBoxDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoHandleBoxManip = {"_p_SoHandleBoxManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoHeightMapToNormalMap = {"_p_SoHeightMapToNormalMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoImage = {"_p_SoImage", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedFaceSet = {"_p_SoIndexedFaceSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedLineSet = {"_p_SoIndexedLineSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedMarkerSet = {"_p_SoIndexedMarkerSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedNurbsCurve = {"_p_SoIndexedNurbsCurve", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedNurbsSurface = {"_p_SoIndexedNurbsSurface", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedPointSet = {"_p_SoIndexedPointSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedShape = {"_p_SoIndexedShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoIndexedTriangleStripSet = {"_p_SoIndexedTriangleStripSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInfo = {"_p_SoInfo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInteractionKit = {"_p_SoInteractionKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInterpolate = {"_p_SoInterpolate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInterpolateFloat = {"_p_SoInterpolateFloat", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInterpolateRotation = {"_p_SoInterpolateRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInterpolateVec2f = {"_p_SoInterpolateVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInterpolateVec3f = {"_p_SoInterpolateVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInterpolateVec4f = {"_p_SoInterpolateVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoJackDragger = {"_p_SoJackDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoJackManip = {"_p_SoJackManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLOD = {"_p_SoLOD", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLabel = {"_p_SoLabel", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLevelOfDetail = {"_p_SoLevelOfDetail", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLight = {"_p_SoLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLightKit = {"_p_SoLightKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLightModel = {"_p_SoLightModel", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLineSet = {"_p_SoLineSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLinearProfile = {"_p_SoLinearProfile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoListener = {"_p_SoListener", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLocateHighlight = {"_p_SoLocateHighlight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMarkerSet = {"_p_SoMarkerSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMaterial = {"_p_SoMaterial", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMaterialBinding = {"_p_SoMaterialBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMatrixTransform = {"_p_SoMatrixTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMultipleCopy = {"_p_SoMultipleCopy", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNodeEngine = {"_p_SoNodeEngine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNodeKitListPart = {"_p_SoNodeKitListPart", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNodeKitPath = {"_p_SoNodeKitPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNonIndexedShape = {"_p_SoNonIndexedShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNormal = {"_p_SoNormal", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNormalBinding = {"_p_SoNormalBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNurbsCurve = {"_p_SoNurbsCurve", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNurbsProfile = {"_p_SoNurbsProfile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoNurbsSurface = {"_p_SoNurbsSurface", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoOnOff = {"_p_SoOnOff", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoOneShot = {"_p_SoOneShot", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoOrthographicCamera = {"_p_SoOrthographicCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPackedColor = {"_p_SoPackedColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPathSwitch = {"_p_SoPathSwitch", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPendulum = {"_p_SoPendulum", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPerspectiveCamera = {"_p_SoPerspectiveCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPickStyle = {"_p_SoPickStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPointLight = {"_p_SoPointLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPointLightDragger = {"_p_SoPointLightDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPointLightManip = {"_p_SoPointLightManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPointSet = {"_p_SoPointSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoPolygonOffset = {"_p_SoPolygonOffset", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoProfile = {"_p_SoProfile", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoProfileCoordinate2 = {"_p_SoProfileCoordinate2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoProfileCoordinate3 = {"_p_SoProfileCoordinate3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoProto = {"_p_SoProto", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoProtoInstance = {"_p_SoProtoInstance", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoQuadMesh = {"_p_SoQuadMesh", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoResetTransform = {"_p_SoResetTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoReversePerspectiveCamera = {"_p_SoReversePerspectiveCamera", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoRotateCylindricalDragger = {"_p_SoRotateCylindricalDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoRotateDiscDragger = {"_p_SoRotateDiscDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoRotateSphericalDragger = {"_p_SoRotateSphericalDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoRotation = {"_p_SoRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoRotationXYZ = {"_p_SoRotationXYZ", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoRotor = {"_p_SoRotor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoScale = {"_p_SoScale", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoScale1Dragger = {"_p_SoScale1Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoScale2Dragger = {"_p_SoScale2Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoScale2UniformDragger = {"_p_SoScale2UniformDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoScaleUniformDragger = {"_p_SoScaleUniformDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSceneKit = {"_p_SoSceneKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSceneTexture2 = {"_p_SoSceneTexture2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSceneTextureCubeMap = {"_p_SoSceneTextureCubeMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSelectOne = {"_p_SoSelectOne", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSeparator = {"_p_SoSeparator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSeparatorKit = {"_p_SoSeparatorKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderObject = {"_p_SoShaderObject", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter = {"_p_SoShaderParameter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter1f = {"_p_SoShaderParameter1f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter1i = {"_p_SoShaderParameter1i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter2f = {"_p_SoShaderParameter2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter2i = {"_p_SoShaderParameter2i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter3f = {"_p_SoShaderParameter3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter3i = {"_p_SoShaderParameter3i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter4f = {"_p_SoShaderParameter4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameter4i = {"_p_SoShaderParameter4i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray1f = {"_p_SoShaderParameterArray1f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray1i = {"_p_SoShaderParameterArray1i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray2f = {"_p_SoShaderParameterArray2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray2i = {"_p_SoShaderParameterArray2i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray3f = {"_p_SoShaderParameterArray3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray3i = {"_p_SoShaderParameterArray3i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray4f = {"_p_SoShaderParameterArray4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterArray4i = {"_p_SoShaderParameterArray4i", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterMatrix = {"_p_SoShaderParameterMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderParameterMatrixArray = {"_p_SoShaderParameterMatrixArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderProgram = {"_p_SoShaderProgram", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShaderStateMatrixParameter = {"_p_SoShaderStateMatrixParameter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShape = {"_p_SoShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShapeHints = {"_p_SoShapeHints", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShapeKit = {"_p_SoShapeKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoShuttle = {"_p_SoShuttle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSphere = {"_p_SoSphere", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSpotLight = {"_p_SoSpotLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSpotLightDragger = {"_p_SoSpotLightDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSpotLightManip = {"_p_SoSpotLightManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSurroundScale = {"_p_SoSurroundScale", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSwitch = {"_p_SoSwitch", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTabBoxDragger = {"_p_SoTabBoxDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTabBoxManip = {"_p_SoTabBoxManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTabPlaneDragger = {"_p_SoTabPlaneDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTempPath = {"_p_SoTempPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoText2 = {"_p_SoText2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoText3 = {"_p_SoText3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTexture = {"_p_SoTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTexture2 = {"_p_SoTexture2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTexture2Convert = {"_p_SoTexture2Convert", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTexture2Transform = {"_p_SoTexture2Transform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTexture3 = {"_p_SoTexture3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTexture3Transform = {"_p_SoTexture3Transform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCombine = {"_p_SoTextureCombine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinate2 = {"_p_SoTextureCoordinate2", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinate3 = {"_p_SoTextureCoordinate3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateBinding = {"_p_SoTextureCoordinateBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateCube = {"_p_SoTextureCoordinateCube", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateCylinder = {"_p_SoTextureCoordinateCylinder", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateDefault = {"_p_SoTextureCoordinateDefault", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateEnvironment = {"_p_SoTextureCoordinateEnvironment", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateFunction = {"_p_SoTextureCoordinateFunction", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateNormalMap = {"_p_SoTextureCoordinateNormalMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateObject = {"_p_SoTextureCoordinateObject", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinatePlane = {"_p_SoTextureCoordinatePlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateReflectionMap = {"_p_SoTextureCoordinateReflectionMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCoordinateSphere = {"_p_SoTextureCoordinateSphere", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureCubeMap = {"_p_SoTextureCubeMap", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureMatrixTransform = {"_p_SoTextureMatrixTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureScalePolicy = {"_p_SoTextureScalePolicy", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTextureUnit = {"_p_SoTextureUnit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTimeCounter = {"_p_SoTimeCounter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTrackballDragger = {"_p_SoTrackballDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTrackballManip = {"_p_SoTrackballManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransform = {"_p_SoTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformBoxDragger = {"_p_SoTransformBoxDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformBoxManip = {"_p_SoTransformBoxManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformManip = {"_p_SoTransformManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformSeparator = {"_p_SoTransformSeparator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformVec3f = {"_p_SoTransformVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformation = {"_p_SoTransformation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformerDragger = {"_p_SoTransformerDragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransformerManip = {"_p_SoTransformerManip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTranslate1Dragger = {"_p_SoTranslate1Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTranslate2Dragger = {"_p_SoTranslate2Dragger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTranslation = {"_p_SoTranslation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTransparencyType = {"_p_SoTransparencyType", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTriangleStripSet = {"_p_SoTriangleStripSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoTriggerAny = {"_p_SoTriggerAny", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoUniformShaderParameter = {"_p_SoUniformShaderParameter", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoUnits = {"_p_SoUnits", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLAnchor = {"_p_SoVRMLAnchor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLAppearance = {"_p_SoVRMLAppearance", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLAudioClip = {"_p_SoVRMLAudioClip", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLBackground = {"_p_SoVRMLBackground", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLBillboard = {"_p_SoVRMLBillboard", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLBox = {"_p_SoVRMLBox", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLCollision = {"_p_SoVRMLCollision", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLColor = {"_p_SoVRMLColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLColorInterpolator = {"_p_SoVRMLColorInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLCone = {"_p_SoVRMLCone", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLCoordinate = {"_p_SoVRMLCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLCoordinateInterpolator = {"_p_SoVRMLCoordinateInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLCylinder = {"_p_SoVRMLCylinder", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLCylinderSensor = {"_p_SoVRMLCylinderSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLDirectionalLight = {"_p_SoVRMLDirectionalLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLDragSensor = {"_p_SoVRMLDragSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLElevationGrid = {"_p_SoVRMLElevationGrid", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLExtrusion = {"_p_SoVRMLExtrusion", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLFog = {"_p_SoVRMLFog", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLFontStyle = {"_p_SoVRMLFontStyle", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLGeometry = {"_p_SoVRMLGeometry", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLGroup = {"_p_SoVRMLGroup", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLImageTexture = {"_p_SoVRMLImageTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedFaceSet = {"_p_SoVRMLIndexedFaceSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedLine = {"_p_SoVRMLIndexedLine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedLineSet = {"_p_SoVRMLIndexedLineSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLIndexedShape = {"_p_SoVRMLIndexedShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLInline = {"_p_SoVRMLInline", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLInterpolator = {"_p_SoVRMLInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLLOD = {"_p_SoVRMLLOD", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLLight = {"_p_SoVRMLLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLMaterial = {"_p_SoVRMLMaterial", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLMovieTexture = {"_p_SoVRMLMovieTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLNavigationInfo = {"_p_SoVRMLNavigationInfo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLNormal = {"_p_SoVRMLNormal", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLNormalInterpolator = {"_p_SoVRMLNormalInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLOrientationInterpolator = {"_p_SoVRMLOrientationInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLParent = {"_p_SoVRMLParent", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLPixelTexture = {"_p_SoVRMLPixelTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLPlaneSensor = {"_p_SoVRMLPlaneSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLPointLight = {"_p_SoVRMLPointLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLPointSet = {"_p_SoVRMLPointSet", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLPositionInterpolator = {"_p_SoVRMLPositionInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLProximitySensor = {"_p_SoVRMLProximitySensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLScalarInterpolator = {"_p_SoVRMLScalarInterpolator", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLScript = {"_p_SoVRMLScript", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLSensor = {"_p_SoVRMLSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLShape = {"_p_SoVRMLShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLSound = {"_p_SoVRMLSound", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLSphere = {"_p_SoVRMLSphere", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLSphereSensor = {"_p_SoVRMLSphereSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLSpotLight = {"_p_SoVRMLSpotLight", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLSwitch = {"_p_SoVRMLSwitch", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLText = {"_p_SoVRMLText", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLTexture = {"_p_SoVRMLTexture", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLTextureCoordinate = {"_p_SoVRMLTextureCoordinate", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLTextureTransform = {"_p_SoVRMLTextureTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLTimeSensor = {"_p_SoVRMLTimeSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLTouchSensor = {"_p_SoVRMLTouchSensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLTransform = {"_p_SoVRMLTransform", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLVertexLine = {"_p_SoVRMLVertexLine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLVertexPoint = {"_p_SoVRMLVertexPoint", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLVertexShape = {"_p_SoVRMLVertexShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLViewpoint = {"_p_SoVRMLViewpoint", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLVisibilitySensor = {"_p_SoVRMLVisibilitySensor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVRMLWorldInfo = {"_p_SoVRMLWorldInfo", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVertexAttribute = {"_p_SoVertexAttribute", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVertexAttributeBinding = {"_p_SoVertexAttributeBinding", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVertexProperty = {"_p_SoVertexProperty", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVertexShader = {"_p_SoVertexShader", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoVertexShape = {"_p_SoVertexShape", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoWWWAnchor = {"_p_SoWWWAnchor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoWWWInline = {"_p_SoWWWInline", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoWrapperKit = {"_p_SoWrapperKit", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoCallbackActionCB = {"_p_SoCallbackActionCB", "SoCallbackActionCB *", 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_SoDebugError = {"_p_SoDebugError", "SoDebugError *", 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_SoEngine = {"_p_SoEngine", "SoEngine *", 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_SoError = {"_p_SoError", "SoError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMemoryError = {"_p_SoMemoryError", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoReadError = {"_p_SoReadError", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoEvent = {"_p_SoEvent", "SoEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoButtonEvent = {"_p_SoButtonEvent", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoKeyboardEvent = {"_p_SoKeyboardEvent", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLocation2Event = {"_p_SoLocation2Event", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMotion3Event = {"_p_SoMotion3Event", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMouseButtonEvent = {"_p_SoMouseButtonEvent", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSpaceballButtonEvent = {"_p_SoSpaceballButtonEvent", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoField = {"_p_SoField", "SoField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoMFBitMask = {"_p_SoMFBitMask", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFBool = {"_p_SoMFBool", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFColor = {"_p_SoMFColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFColorRGBA = {"_p_SoMFColorRGBA", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFDouble = {"_p_SoMFDouble", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFEngine = {"_p_SoMFEngine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFEnum = {"_p_SoMFEnum", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFFloat = {"_p_SoMFFloat", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFInt32 = {"_p_SoMFInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFMatrix = {"_p_SoMFMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFName = {"_p_SoMFName", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFNode = {"_p_SoMFNode", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFPath = {"_p_SoMFPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFPlane = {"_p_SoMFPlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFRotation = {"_p_SoMFRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFShort = {"_p_SoMFShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFString = {"_p_SoMFString", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFTime = {"_p_SoMFTime", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFUInt32 = {"_p_SoMFUInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFUShort = {"_p_SoMFUShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec2b = {"_p_SoMFVec2b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec2d = {"_p_SoMFVec2d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec2i32 = {"_p_SoMFVec2i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec2s = {"_p_SoMFVec2s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec3b = {"_p_SoMFVec3b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec3i32 = {"_p_SoMFVec3i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec3s = {"_p_SoMFVec3s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec4b = {"_p_SoMFVec4b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec4d = {"_p_SoMFVec4d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec4i32 = {"_p_SoMFVec4i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec4s = {"_p_SoMFVec4s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec4ub = {"_p_SoMFVec4ub", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec4ui32 = {"_p_SoMFVec4ui32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoMFVec4us = {"_p_SoMFVec4us", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBitMask = {"_p_SoSFBitMask", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBool = {"_p_SoSFBool", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox2d = {"_p_SoSFBox2d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox2f = {"_p_SoSFBox2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox2i32 = {"_p_SoSFBox2i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox2s = {"_p_SoSFBox2s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox3d = {"_p_SoSFBox3d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox3f = {"_p_SoSFBox3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox3i32 = {"_p_SoSFBox3i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFBox3s = {"_p_SoSFBox3s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFColor = {"_p_SoSFColor", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFColorRGBA = {"_p_SoSFColorRGBA", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFDouble = {"_p_SoSFDouble", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFEngine = {"_p_SoSFEngine", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFEnum = {"_p_SoSFEnum", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFFloat = {"_p_SoSFFloat", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFImage = {"_p_SoSFImage", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFImage3 = {"_p_SoSFImage3", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFInt32 = {"_p_SoSFInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFMatrix = {"_p_SoSFMatrix", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFName = {"_p_SoSFName", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFNode = {"_p_SoSFNode", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFPath = {"_p_SoSFPath", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFPlane = {"_p_SoSFPlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFRotation = {"_p_SoSFRotation", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFShort = {"_p_SoSFShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFString = {"_p_SoSFString", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFTime = {"_p_SoSFTime", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFTrigger = {"_p_SoSFTrigger", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFUInt32 = {"_p_SoSFUInt32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFUShort = {"_p_SoSFUShort", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec2b = {"_p_SoSFVec2b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec2d = {"_p_SoSFVec2d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec2f = {"_p_SoSFVec2f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec2i32 = {"_p_SoSFVec2i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec2s = {"_p_SoSFVec2s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec3b = {"_p_SoSFVec3b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec3d = {"_p_SoSFVec3d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec3f = {"_p_SoSFVec3f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec3i32 = {"_p_SoSFVec3i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec3s = {"_p_SoSFVec3s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4b = {"_p_SoSFVec4b", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4d = {"_p_SoSFVec4d", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4f = {"_p_SoSFVec4f", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4i32 = {"_p_SoSFVec4i32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4s = {"_p_SoSFVec4s", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4ub = {"_p_SoSFVec4ub", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4ui32 = {"_p_SoSFVec4ui32", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoSFVec4us = {"_p_SoSFVec4us", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoFieldContainer = {"_p_SoFieldContainer", "SoFieldContainer *", 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_SoGLImageResizeCB = {"_p_SoGLImageResizeCB", "SoGLImageResizeCB *", 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_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_SoBoxHighlightRenderAction = {"_p_SoBoxHighlightRenderAction", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoLineHighlightRenderAction = {"_p_SoLineHighlightRenderAction", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_SoInput = {"_p_SoInput", "SoInput *", 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_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_SoMFVec2f = {"_p_SoMFVec2f", "SoMFVec2f *", 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_SoMFVec4f = {"_p_SoMFVec4f", "SoMFVec4f *", 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_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_SoMultiTextureImageElement = {"_p_SoMultiTextureImageElement", "SoTextureImageElement *|SoMultiTextureImageElement *", 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_SoNode = {"_p_SoNode", "SoNode *", 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_SoOutput = {"_p_SoOutput", "SoOutput *", 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_SoQt = {"_p_SoQt", "SoQt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtComponent = {"_p_SoQtComponent", "SoQtComponent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtConstrainedViewer = {"_p_SoQtConstrainedViewer", "SoQtConstrainedViewer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtCursor = {"_p_SoQtCursor", "SoQtCursor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtCursor__CustomCursor = {"_p_SoQtCursor__CustomCursor", "SoQtCursor::CustomCursor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtDevice = {"_p_SoQtDevice", "SoQtDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtExaminerViewer = {"_p_SoQtExaminerViewer", "SoQtExaminerViewer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtFlyViewer = {"_p_SoQtFlyViewer", "SoQtFlyViewer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtFullViewer = {"_p_SoQtFullViewer", "SoQtFullViewer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtGLWidget = {"_p_SoQtGLWidget", "SoQtGLWidget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtKeyboard = {"_p_SoQtKeyboard", "SoQtKeyboard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtMouse = {"_p_SoQtMouse", "SoQtMouse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtObject = {"_p_SoQtObject", "SoQtObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtPlaneViewer = {"_p_SoQtPlaneViewer", "SoQtPlaneViewer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtPopupMenu = {"_p_SoQtPopupMenu", "SoQtPopupMenu *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtRenderArea = {"_p_SoQtRenderArea", "SoQtRenderArea *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SoQtViewer = {"_p_SoQtViewer", "SoQtViewer *", 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_SoSceneManager = {"_p_SoSceneManager", "SoSceneManager *", 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_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_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_cc_glglue = {"_p_cc_glglue", "cc_glue *|cc_glglue *", 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_p_SoQtViewer__void = {"_p_f_float_p_void_p_SoQtViewer__void", "SoQtViewerFPSCB *|void (*)(float,void *,SoQtViewer *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_p_void__void = {"_p_f_int_p_void__void", "SoQtMenuSelectionCallback *|void (*)(int,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_QWidget_p_void_p_QEvent_p_bool__void = {"_p_f_p_QWidget_p_void_p_QEvent_p_bool__void", "SoQtEventHandler *|void (*)(QWidget *,void *,QEvent *,bool *)", 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_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__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", "SoQtComponentVisibilityCB *|void (*)(void *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_QEvent__int = {"_p_f_p_void_p_QEvent__int", "SoQtRenderAreaEventCB *|int (*)(void *,QEvent *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_QEvent__intp = {"_p_f_p_void_p_QEvent__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__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_SoQtComponent__void = {"_p_f_p_void_p_SoQtComponent__void", "SoQtComponentCB *|void (*)(void *,SoQtComponent *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_SoQtViewer__void = {"_p_f_p_void_p_SoQtViewer__void", "SoQtViewerCB *|void (*)(void *,SoQtViewer *)", 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 *|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_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__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__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__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_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__SbVec2f__SbVec2f = {"_p_f_p_void_r_q_const__SbVec2f__SbVec2f", "SoQtAutoClippingCB *|SbVec2f (*)(void *,SbVec2f const &)", 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__SbString_enum_SoQt__FatalErrors_p_void__void = {"_p_f_q_const__SbString_enum_SoQt__FatalErrors_p_void__void", "SoQt::FatalErrorCB *|void (*)(SbString const,enum SoQt::FatalErrors,void *)", 0, 0, (void*)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__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_unsigned_int_p_void__void = {"_p_f_unsigned_int_p_void__void", "SbDictApplyFunc *|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_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_SoMField = {"_p_p_SoMField", 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_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_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_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_FatalErrorCB,
  &_swigt__p_Key,
  &_swigt__p_ProgressCallbackType,
  &_swigt__p_QEvent,
  &_swigt__p_QWidget,
  &_swigt__p_SbColor,
  &_swigt__p_SbColor4f,
  &_swigt__p_SbDPMatrix,
  &_swigt__p_SbDPRotation,
  &_swigt__p_SbDict,
  &_swigt__p_SbHeapFuncs,
  &_swigt__p_SbIntList,
  &_swigt__p_SbMatrix,
  &_swigt__p_SbName,
  &_swigt__p_SbOctTreeFuncs,
  &_swigt__p_SbPList,
  &_swigt__p_SbPlane,
  &_swigt__p_SbRotation,
  &_swigt__p_SbString,
  &_swigt__p_SbStringList,
  &_swigt__p_SbTime,
  &_swigt__p_SbVec2b,
  &_swigt__p_SbVec2d,
  &_swigt__p_SbVec2f,
  &_swigt__p_SbVec2i32,
  &_swigt__p_SbVec2s,
  &_swigt__p_SbVec2us,
  &_swigt__p_SbVec3d,
  &_swigt__p_SbVec3f,
  &_swigt__p_SbVec3fList,
  &_swigt__p_SbVec4f,
  &_swigt__p_SbViewportRegion,
  &_swigt__p_SoActionMethodList,
  &_swigt__p_SoAlphaTest,
  &_swigt__p_SoAnnotation,
  &_swigt__p_SoAntiSquish,
  &_swigt__p_SoAppearanceKit,
  &_swigt__p_SoArray,
  &_swigt__p_SoAsciiText,
  &_swigt__p_SoAuditorList,
  &_swigt__p_SoBase,
  &_swigt__p_SoBaseColor,
  &_swigt__p_SoBaseKit,
  &_swigt__p_SoBaseList,
  &_swigt__p_SoBlinker,
  &_swigt__p_SoBoolOperation,
  &_swigt__p_SoBoxHighlightRenderAction,
  &_swigt__p_SoBumpMap,
  &_swigt__p_SoBumpMapCoordinate,
  &_swigt__p_SoBumpMapTransform,
  &_swigt__p_SoButtonEvent,
  &_swigt__p_SoCacheHint,
  &_swigt__p_SoCalculator,
  &_swigt__p_SoCallback,
  &_swigt__p_SoCallbackActionCB,
  &_swigt__p_SoCamera,
  &_swigt__p_SoCameraKit,
  &_swigt__p_SoCenterballDragger,
  &_swigt__p_SoCenterballManip,
  &_swigt__p_SoChildList,
  &_swigt__p_SoClipPlane,
  &_swigt__p_SoClipPlaneManip,
  &_swigt__p_SoColorIndex,
  &_swigt__p_SoComplexity,
  &_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_SoCoordinate3,
  &_swigt__p_SoCoordinate4,
  &_swigt__p_SoCounter,
  &_swigt__p_SoCube,
  &_swigt__p_SoCylinder,
  &_swigt__p_SoDebugError,
  &_swigt__p_SoDecomposeMatrix,
  &_swigt__p_SoDecomposeRotation,
  &_swigt__p_SoDecomposeVec2f,
  &_swigt__p_SoDecomposeVec3f,
  &_swigt__p_SoDecomposeVec4f,
  &_swigt__p_SoDepthBuffer,
  &_swigt__p_SoDetailList,
  &_swigt__p_SoDirectionalLight,
  &_swigt__p_SoDirectionalLightDragger,
  &_swigt__p_SoDirectionalLightManip,
  &_swigt__p_SoDragPointDragger,
  &_swigt__p_SoDragger,
  &_swigt__p_SoDrawStyle,
  &_swigt__p_SoElapsedTime,
  &_swigt__p_SoEngine,
  &_swigt__p_SoEngineList,
  &_swigt__p_SoEngineOutput,
  &_swigt__p_SoEngineOutputList,
  &_swigt__p_SoEnvironment,
  &_swigt__p_SoError,
  &_swigt__p_SoEvent,
  &_swigt__p_SoEventCallback,
  &_swigt__p_SoExtSelection,
  &_swigt__p_SoFaceSet,
  &_swigt__p_SoField,
  &_swigt__p_SoFieldContainer,
  &_swigt__p_SoFieldConverter,
  &_swigt__p_SoFieldList,
  &_swigt__p_SoFile,
  &_swigt__p_SoFont,
  &_swigt__p_SoFontStyle,
  &_swigt__p_SoFragmentShader,
  &_swigt__p_SoFrustumCamera,
  &_swigt__p_SoFullPath,
  &_swigt__p_SoGLImageResizeCB,
  &_swigt__p_SoGLMultiTextureCoordinateElement,
  &_swigt__p_SoGLMultiTextureEnabledElement,
  &_swigt__p_SoGLMultiTextureImageElement,
  &_swigt__p_SoGLMultiTextureMatrixElement,
  &_swigt__p_SoGLRenderAbortCB,
  &_swigt__p_SoGLRenderAction,
  &_swigt__p_SoGate,
  &_swigt__p_SoGeoCoordinate,
  &_swigt__p_SoGeoLocation,
  &_swigt__p_SoGeoOrigin,
  &_swigt__p_SoGeoSeparator,
  &_swigt__p_SoGroup,
  &_swigt__p_SoHandleBoxDragger,
  &_swigt__p_SoHandleBoxManip,
  &_swigt__p_SoHeightMapToNormalMap,
  &_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_SoInteractionKit,
  &_swigt__p_SoInterpolate,
  &_swigt__p_SoInterpolateFloat,
  &_swigt__p_SoInterpolateRotation,
  &_swigt__p_SoInterpolateVec2f,
  &_swigt__p_SoInterpolateVec3f,
  &_swigt__p_SoInterpolateVec4f,
  &_swigt__p_SoIntersectionCB,
  &_swigt__p_SoIntersectionFilterCB,
  &_swigt__p_SoIntersectionVisitationCB,
  &_swigt__p_SoJackDragger,
  &_swigt__p_SoJackManip,
  &_swigt__p_SoKeyboardEvent,
  &_swigt__p_SoLOD,
  &_swigt__p_SoLabel,
  &_swigt__p_SoLevelOfDetail,
  &_swigt__p_SoLight,
  &_swigt__p_SoLightKit,
  &_swigt__p_SoLightModel,
  &_swigt__p_SoLineHighlightRenderAction,
  &_swigt__p_SoLineSet,
  &_swigt__p_SoLinearProfile,
  &_swigt__p_SoListener,
  &_swigt__p_SoLocateHighlight,
  &_swigt__p_SoLocation2Event,
  &_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_SoMatrixTransform,
  &_swigt__p_SoMemoryError,
  &_swigt__p_SoMotion3Event,
  &_swigt__p_SoMouseButtonEvent,
  &_swigt__p_SoMultiTextureCoordinateElement,
  &_swigt__p_SoMultiTextureEnabledElement,
  &_swigt__p_SoMultiTextureImageElement,
  &_swigt__p_SoMultiTextureMatrixElement,
  &_swigt__p_SoMultipleCopy,
  &_swigt__p_SoNode,
  &_swigt__p_SoNodeEngine,
  &_swigt__p_SoNodeKitListPart,
  &_swigt__p_SoNodeKitPath,
  &_swigt__p_SoNodeList,
  &_swigt__p_SoNonIndexedShape,
  &_swigt__p_SoNormal,
  &_swigt__p_SoNormalBinding,
  &_swigt__p_SoNotList,
  &_swigt__p_SoNotRec,
  &_swigt__p_SoNurbsCurve,
  &_swigt__p_SoNurbsProfile,
  &_swigt__p_SoNurbsSurface,
  &_swigt__p_SoOnOff,
  &_swigt__p_SoOneShot,
  &_swigt__p_SoOrthographicCamera,
  &_swigt__p_SoOutput,
  &_swigt__p_SoPackedColor,
  &_swigt__p_SoPath,
  &_swigt__p_SoPathList,
  &_swigt__p_SoPathSwitch,
  &_swigt__p_SoPendulum,
  &_swigt__p_SoPerspectiveCamera,
  &_swigt__p_SoPickStyle,
  &_swigt__p_SoPickedPointList,
  &_swigt__p_SoPointLight,
  &_swigt__p_SoPointLightDragger,
  &_swigt__p_SoPointLightManip,
  &_swigt__p_SoPointSet,
  &_swigt__p_SoPolygonOffset,
  &_swigt__p_SoProfile,
  &_swigt__p_SoProfileCoordinate2,
  &_swigt__p_SoProfileCoordinate3,
  &_swigt__p_SoProto,
  &_swigt__p_SoProtoInstance,
  &_swigt__p_SoQt,
  &_swigt__p_SoQtComponent,
  &_swigt__p_SoQtConstrainedViewer,
  &_swigt__p_SoQtCursor,
  &_swigt__p_SoQtCursor__CustomCursor,
  &_swigt__p_SoQtDevice,
  &_swigt__p_SoQtExaminerViewer,
  &_swigt__p_SoQtFlyViewer,
  &_swigt__p_SoQtFullViewer,
  &_swigt__p_SoQtGLWidget,
  &_swigt__p_SoQtKeyboard,
  &_swigt__p_SoQtMouse,
  &_swigt__p_SoQtObject,
  &_swigt__p_SoQtPlaneViewer,
  &_swigt__p_SoQtPopupMenu,
  &_swigt__p_SoQtRenderArea,
  &_swigt__p_SoQtViewer,
  &_swigt__p_SoQuadMesh,
  &_swigt__p_SoReadError,
  &_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_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_SoSelectOne,
  &_swigt__p_SoSelection,
  &_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_SoShapeKit,
  &_swigt__p_SoShuttle,
  &_swigt__p_SoSpaceballButtonEvent,
  &_swigt__p_SoSphere,
  &_swigt__p_SoSpotLight,
  &_swigt__p_SoSpotLightDragger,
  &_swigt__p_SoSpotLightManip,
  &_swigt__p_SoSurroundScale,
  &_swigt__p_SoSwitch,
  &_swigt__p_SoTabBoxDragger,
  &_swigt__p_SoTabBoxManip,
  &_swigt__p_SoTabPlaneDragger,
  &_swigt__p_SoTempPath,
  &_swigt__p_SoText2,
  &_swigt__p_SoText3,
  &_swigt__p_SoTexture,
  &_swigt__p_SoTexture2,
  &_swigt__p_SoTexture2Convert,
  &_swigt__p_SoTexture2Transform,
  &_swigt__p_SoTexture3,
  &_swigt__p_SoTexture3Transform,
  &_swigt__p_SoTextureCombine,
  &_swigt__p_SoTextureCoordinate2,
  &_swigt__p_SoTextureCoordinate3,
  &_swigt__p_SoTextureCoordinateBinding,
  &_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_SoTextureScalePolicy,
  &_swigt__p_SoTextureUnit,
  &_swigt__p_SoTimeCounter,
  &_swigt__p_SoTrackballDragger,
  &_swigt__p_SoTrackballManip,
  &_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_SoTransparencyType,
  &_swigt__p_SoTriangleStripSet,
  &_swigt__p_SoTriggerAny,
  &_swigt__p_SoType,
  &_swigt__p_SoTypeList,
  &_swigt__p_SoUniformShaderParameter,
  &_swigt__p_SoUnits,
  &_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_SoVertexAttribute,
  &_swigt__p_SoVertexAttributeBinding,
  &_swigt__p_SoVertexProperty,
  &_swigt__p_SoVertexShader,
  &_swigt__p_SoVertexShape,
  &_swigt__p_SoWWWAnchor,
  &_swigt__p_SoWWWInline,
  &_swigt__p_SoWrapperKit,
  &_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_cc_glglue,
  &_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_p_SoQtViewer__void,
  &_swigt__p_f_int_p_void__void,
  &_swigt__p_f_p_QWidget_p_void_p_QEvent_p_bool__void,
  &_swigt__p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto,
  &_swigt__p_f_p_q_const__SoError_p_void__void,
  &_swigt__p_f_p_void__void,
  &_swigt__p_f_p_void_int__void,
  &_swigt__p_f_p_void_p_QEvent__int,
  &_swigt__p_f_p_void_p_QEvent__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__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_SoQtComponent__void,
  &_swigt__p_f_p_void_p_SoQtViewer__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_SoVRMLScript__void,
  &_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__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__void,
  &_swigt__p_f_p_void_p_void_p_void_p_void__void,
  &_swigt__p_f_p_void_r_q_const__SbVec2f__SbVec2f,
  &_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__SbString_enum_SoQt__FatalErrors_p_void__void,
  &_swigt__p_f_q_const__unsigned_int__unsigned_int,
  &_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_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_SoEngineOutput,
  &_swigt__p_p_SoField,
  &_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_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_char,
  &_swigt__p_p_charp,
  &_swigt__p_p_void,
  &_swigt__p_read_func,
  &_swigt__p_seek_func,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_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_FatalErrorCB[] = {  {&_swigt__p_FatalErrorCB, 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_QEvent[] = {  {&_swigt__p_QEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QWidget[] = {  {&_swigt__p_QWidget, 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_SbDPMatrix[] = {  {&_swigt__p_SbDPMatrix, 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_SbDict[] = {  {&_swigt__p_SbDict, 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_SbIntList[] = {  {&_swigt__p_SbIntList, 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_SbName[] = {  {&_swigt__p_SbName, 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_SbStringList[] = {{&_swigt__p_SbStringList, 0, 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_SoActionMethodList[] = {{&_swigt__p_SoActionMethodList, 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_SoBaseList[] = {{&_swigt__p_SoBaseList, 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_SoDetailList[] = {{&_swigt__p_SoDetailList, 0, 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_SoEngineOutputList[] = {{&_swigt__p_SoEngineOutputList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoNodeList[] = {{&_swigt__p_SoNodeList, 0, 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_SoPickedPointList[] = {{&_swigt__p_SoPickedPointList, 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_SbRotation[] = {  {&_swigt__p_SbRotation, 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_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_SbVec2us[] = {  {&_swigt__p_SbVec2us, 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_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_SbViewportRegion[] = {  {&_swigt__p_SbViewportRegion, 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_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_SoBaseColor[] = {{&_swigt__p_SoBaseColor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoBaseKit[] = {{&_swigt__p_SoBaseKit, 0, 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_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_SoBumpMapTransform[] = {{&_swigt__p_SoBumpMapTransform, 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_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_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_SoClipPlane[] = {{&_swigt__p_SoClipPlane, 0, 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_SoComplexity[] = {{&_swigt__p_SoComplexity, 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_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_SoCounter[] = {{&_swigt__p_SoCounter, 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_SoCylinder[] = {{&_swigt__p_SoCylinder, 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_SoDepthBuffer[] = {{&_swigt__p_SoDepthBuffer, 0, 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},{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_SoElapsedTime[] = {{&_swigt__p_SoElapsedTime, 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_SoEventCallback[] = {{&_swigt__p_SoEventCallback, 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_SoFaceSet[] = {{&_swigt__p_SoFaceSet, 0, 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_SoFile[] = {{&_swigt__p_SoFile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoFont[] = {{&_swigt__p_SoFont, 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},{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_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_SoGroup[] = {{&_swigt__p_SoGroup, 0, 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_SoHeightMapToNormalMap[] = {{&_swigt__p_SoHeightMapToNormalMap, 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},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoIndexedShape[] = {{&_swigt__p_SoIndexedShape, 0, 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_SoInteractionKit[] = {{&_swigt__p_SoInteractionKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoInterpolate[] = {{&_swigt__p_SoInterpolate, 0, 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_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_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_SoLevelOfDetail[] = {{&_swigt__p_SoLevelOfDetail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoLight[] = {{&_swigt__p_SoLight, 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_SoLineSet[] = {{&_swigt__p_SoLineSet, 0, 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_SoLocateHighlight[] = {{&_swigt__p_SoLocateHighlight, 0, 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_SoMatrixTransform[] = {{&_swigt__p_SoMatrixTransform, 0, 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_SoNodeEngine[] = {{&_swigt__p_SoNodeEngine, 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_SoNonIndexedShape[] = {{&_swigt__p_SoNonIndexedShape, 0, 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_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_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_SoOrthographicCamera[] = {{&_swigt__p_SoOrthographicCamera, 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_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},{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_SoPointLight[] = {{&_swigt__p_SoPointLight, 0, 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},{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_SoProfile[] = {{&_swigt__p_SoProfile, 0, 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_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_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},{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_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_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_SoSelectOne[] = {{&_swigt__p_SoSelectOne, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSeparator[] = {{&_swigt__p_SoSeparator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSeparatorKit[] = {{&_swigt__p_SoSeparatorKit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderObject[] = {{&_swigt__p_SoShaderObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoShaderParameter[] = {{&_swigt__p_SoShaderParameter, 0, 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},{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_SoShapeKit[] = {{&_swigt__p_SoShapeKit, 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_SoSphere[] = {{&_swigt__p_SoSphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSpotLight[] = {{&_swigt__p_SoSpotLight, 0, 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_SoSurroundScale[] = {{&_swigt__p_SoSurroundScale, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoSwitch[] = {{&_swigt__p_SoSwitch, 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_SoTexture[] = {{&_swigt__p_SoTexture, 0, 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},{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_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_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},{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_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_SoTimeCounter[] = {{&_swigt__p_SoTimeCounter, 0, 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_SoTransform[] = {{&_swigt__p_SoTransform, 0, 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},{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},{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},{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_SoUniformShaderParameter[] = {{&_swigt__p_SoUniformShaderParameter, 0, 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_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},{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},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLGroup[] = {{&_swigt__p_SoVRMLGroup, 0, 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},{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},{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},{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},{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},{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},{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},{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},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLVertexPoint[] = {{&_swigt__p_SoVRMLVertexPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoVRMLVertexShape[] = {{&_swigt__p_SoVRMLVertexShape, 0, 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_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_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},{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_SoWrapperKit[] = {{&_swigt__p_SoWrapperKit, 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_SoCallbackActionCB[] = {  {&_swigt__p_SoCallbackActionCB, 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_SoDebugError[] = {  {&_swigt__p_SoDebugError, 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_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_SoEngineOutput[] = {  {&_swigt__p_SoEngineOutput, 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_SoReadError[] = {{&_swigt__p_SoReadError, 0, 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_SoButtonEvent[] = {{&_swigt__p_SoButtonEvent, 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_SoLocation2Event[] = {{&_swigt__p_SoLocation2Event, 0, 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_SoSpaceballButtonEvent[] = {{&_swigt__p_SoSpaceballButtonEvent, 0, 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_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},{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_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_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_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_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},{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_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_SoFieldList[] = {  {&_swigt__p_SoFieldList, 0, 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_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_SoGLRenderAbortCB[] = {  {&_swigt__p_SoGLRenderAbortCB, 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_SoLineHighlightRenderAction[] = {{&_swigt__p_SoLineHighlightRenderAction, 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_SoInput[] = {  {&_swigt__p_SoInput, 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_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_SoMFVec2f[] = {  {&_swigt__p_SoMFVec2f, 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_SoMFVec4f[] = {  {&_swigt__p_SoMFVec4f, 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_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_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_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_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_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_SoOutput[] = {  {&_swigt__p_SoOutput, 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_SoQt[] = {  {&_swigt__p_SoQt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtComponent[] = {  {&_swigt__p_SoQtComponent, 0, 0, 0},  {&_swigt__p_SoQtConstrainedViewer, _p_SoQtConstrainedViewerTo_p_SoQtComponent, 0, 0},  {&_swigt__p_SoQtExaminerViewer, _p_SoQtExaminerViewerTo_p_SoQtComponent, 0, 0},  {&_swigt__p_SoQtFlyViewer, _p_SoQtFlyViewerTo_p_SoQtComponent, 0, 0},  {&_swigt__p_SoQtFullViewer, _p_SoQtFullViewerTo_p_SoQtComponent, 0, 0},  {&_swigt__p_SoQtGLWidget, _p_SoQtGLWidgetTo_p_SoQtComponent, 0, 0},  {&_swigt__p_SoQtPlaneViewer, _p_SoQtPlaneViewerTo_p_SoQtComponent, 0, 0},  {&_swigt__p_SoQtRenderArea, _p_SoQtRenderAreaTo_p_SoQtComponent, 0, 0},  {&_swigt__p_SoQtViewer, _p_SoQtViewerTo_p_SoQtComponent, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtConstrainedViewer[] = {  {&_swigt__p_SoQtConstrainedViewer, 0, 0, 0},  {&_swigt__p_SoQtFlyViewer, _p_SoQtFlyViewerTo_p_SoQtConstrainedViewer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtCursor[] = {  {&_swigt__p_SoQtCursor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtCursor__CustomCursor[] = {  {&_swigt__p_SoQtCursor__CustomCursor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtDevice[] = {  {&_swigt__p_SoQtDevice, 0, 0, 0},  {&_swigt__p_SoQtKeyboard, _p_SoQtKeyboardTo_p_SoQtDevice, 0, 0},  {&_swigt__p_SoQtMouse, _p_SoQtMouseTo_p_SoQtDevice, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtExaminerViewer[] = {  {&_swigt__p_SoQtExaminerViewer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtFlyViewer[] = {  {&_swigt__p_SoQtFlyViewer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtFullViewer[] = {  {&_swigt__p_SoQtFullViewer, 0, 0, 0},  {&_swigt__p_SoQtConstrainedViewer, _p_SoQtConstrainedViewerTo_p_SoQtFullViewer, 0, 0},  {&_swigt__p_SoQtExaminerViewer, _p_SoQtExaminerViewerTo_p_SoQtFullViewer, 0, 0},  {&_swigt__p_SoQtFlyViewer, _p_SoQtFlyViewerTo_p_SoQtFullViewer, 0, 0},  {&_swigt__p_SoQtPlaneViewer, _p_SoQtPlaneViewerTo_p_SoQtFullViewer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtGLWidget[] = {  {&_swigt__p_SoQtGLWidget, 0, 0, 0},  {&_swigt__p_SoQtConstrainedViewer, _p_SoQtConstrainedViewerTo_p_SoQtGLWidget, 0, 0},  {&_swigt__p_SoQtExaminerViewer, _p_SoQtExaminerViewerTo_p_SoQtGLWidget, 0, 0},  {&_swigt__p_SoQtFlyViewer, _p_SoQtFlyViewerTo_p_SoQtGLWidget, 0, 0},  {&_swigt__p_SoQtFullViewer, _p_SoQtFullViewerTo_p_SoQtGLWidget, 0, 0},  {&_swigt__p_SoQtPlaneViewer, _p_SoQtPlaneViewerTo_p_SoQtGLWidget, 0, 0},  {&_swigt__p_SoQtRenderArea, _p_SoQtRenderAreaTo_p_SoQtGLWidget, 0, 0},  {&_swigt__p_SoQtViewer, _p_SoQtViewerTo_p_SoQtGLWidget, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtKeyboard[] = {  {&_swigt__p_SoQtKeyboard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtMouse[] = {  {&_swigt__p_SoQtMouse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtObject[] = {  {&_swigt__p_SoQtObject, 0, 0, 0},  {&_swigt__p_SoQtComponent, _p_SoQtComponentTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtConstrainedViewer, _p_SoQtConstrainedViewerTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtDevice, _p_SoQtDeviceTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtExaminerViewer, _p_SoQtExaminerViewerTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtFlyViewer, _p_SoQtFlyViewerTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtFullViewer, _p_SoQtFullViewerTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtGLWidget, _p_SoQtGLWidgetTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtKeyboard, _p_SoQtKeyboardTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtMouse, _p_SoQtMouseTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtPlaneViewer, _p_SoQtPlaneViewerTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtRenderArea, _p_SoQtRenderAreaTo_p_SoQtObject, 0, 0},  {&_swigt__p_SoQtViewer, _p_SoQtViewerTo_p_SoQtObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtPlaneViewer[] = {  {&_swigt__p_SoQtPlaneViewer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtPopupMenu[] = {  {&_swigt__p_SoQtPopupMenu, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtRenderArea[] = {  {&_swigt__p_SoQtRenderArea, 0, 0, 0},  {&_swigt__p_SoQtConstrainedViewer, _p_SoQtConstrainedViewerTo_p_SoQtRenderArea, 0, 0},  {&_swigt__p_SoQtExaminerViewer, _p_SoQtExaminerViewerTo_p_SoQtRenderArea, 0, 0},  {&_swigt__p_SoQtFlyViewer, _p_SoQtFlyViewerTo_p_SoQtRenderArea, 0, 0},  {&_swigt__p_SoQtFullViewer, _p_SoQtFullViewerTo_p_SoQtRenderArea, 0, 0},  {&_swigt__p_SoQtPlaneViewer, _p_SoQtPlaneViewerTo_p_SoQtRenderArea, 0, 0},  {&_swigt__p_SoQtViewer, _p_SoQtViewerTo_p_SoQtRenderArea, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SoQtViewer[] = {  {&_swigt__p_SoQtViewer, 0, 0, 0},  {&_swigt__p_SoQtConstrainedViewer, _p_SoQtConstrainedViewerTo_p_SoQtViewer, 0, 0},  {&_swigt__p_SoQtExaminerViewer, _p_SoQtExaminerViewerTo_p_SoQtViewer, 0, 0},  {&_swigt__p_SoQtFlyViewer, _p_SoQtFlyViewerTo_p_SoQtViewer, 0, 0},  {&_swigt__p_SoQtFullViewer, _p_SoQtFullViewerTo_p_SoQtViewer, 0, 0},  {&_swigt__p_SoQtPlaneViewer, _p_SoQtPlaneViewerTo_p_SoQtViewer, 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_SoSceneManager[] = {  {&_swigt__p_SoSceneManager, 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_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_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_cc_glglue[] = {  {&_swigt__p_cc_glglue, 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_p_SoQtViewer__void[] = {  {&_swigt__p_f_float_p_void_p_SoQtViewer__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_p_void__void[] = {  {&_swigt__p_f_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_QWidget_p_void_p_QEvent_p_bool__void[] = {  {&_swigt__p_f_p_QWidget_p_void_p_QEvent_p_bool__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_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__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_p_QEvent__intp[] = {{&_swigt__p_f_p_void_p_QEvent__intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_QEvent__int[] = {  {&_swigt__p_f_p_void_p_QEvent__int, 0, 0, 0},  {&_swigt__p_f_p_void_p_QEvent__intp, _p_f_p_void_p_QEvent__intpTo_p_f_p_void_p_QEvent__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__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_SoQtComponent__void[] = {  {&_swigt__p_f_p_void_p_SoQtComponent__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_SoQtViewer__void[] = {  {&_swigt__p_f_p_void_p_SoQtViewer__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_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__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__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__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_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__SbVec2f__SbVec2f[] = {  {&_swigt__p_f_p_void_r_q_const__SbVec2f__SbVec2f, 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__SbString_enum_SoQt__FatalErrors_p_void__void[] = {  {&_swigt__p_f_q_const__SbString_enum_SoQt__FatalErrors_p_void__void, 0, 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__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_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_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_SoMField[] = {{&_swigt__p_p_SoMField, 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_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_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_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_FatalErrorCB,
  _swigc__p_Key,
  _swigc__p_ProgressCallbackType,
  _swigc__p_QEvent,
  _swigc__p_QWidget,
  _swigc__p_SbColor,
  _swigc__p_SbColor4f,
  _swigc__p_SbDPMatrix,
  _swigc__p_SbDPRotation,
  _swigc__p_SbDict,
  _swigc__p_SbHeapFuncs,
  _swigc__p_SbIntList,
  _swigc__p_SbMatrix,
  _swigc__p_SbName,
  _swigc__p_SbOctTreeFuncs,
  _swigc__p_SbPList,
  _swigc__p_SbPlane,
  _swigc__p_SbRotation,
  _swigc__p_SbString,
  _swigc__p_SbStringList,
  _swigc__p_SbTime,
  _swigc__p_SbVec2b,
  _swigc__p_SbVec2d,
  _swigc__p_SbVec2f,
  _swigc__p_SbVec2i32,
  _swigc__p_SbVec2s,
  _swigc__p_SbVec2us,
  _swigc__p_SbVec3d,
  _swigc__p_SbVec3f,
  _swigc__p_SbVec3fList,
  _swigc__p_SbVec4f,
  _swigc__p_SbViewportRegion,
  _swigc__p_SoActionMethodList,
  _swigc__p_SoAlphaTest,
  _swigc__p_SoAnnotation,
  _swigc__p_SoAntiSquish,
  _swigc__p_SoAppearanceKit,
  _swigc__p_SoArray,
  _swigc__p_SoAsciiText,
  _swigc__p_SoAuditorList,
  _swigc__p_SoBase,
  _swigc__p_SoBaseColor,
  _swigc__p_SoBaseKit,
  _swigc__p_SoBaseList,
  _swigc__p_SoBlinker,
  _swigc__p_SoBoolOperation,
  _swigc__p_SoBoxHighlightRenderAction,
  _swigc__p_SoBumpMap,
  _swigc__p_SoBumpMapCoordinate,
  _swigc__p_SoBumpMapTransform,
  _swigc__p_SoButtonEvent,
  _swigc__p_SoCacheHint,
  _swigc__p_SoCalculator,
  _swigc__p_SoCallback,
  _swigc__p_SoCallbackActionCB,
  _swigc__p_SoCamera,
  _swigc__p_SoCameraKit,
  _swigc__p_SoCenterballDragger,
  _swigc__p_SoCenterballManip,
  _swigc__p_SoChildList,
  _swigc__p_SoClipPlane,
  _swigc__p_SoClipPlaneManip,
  _swigc__p_SoColorIndex,
  _swigc__p_SoComplexity,
  _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_SoCoordinate3,
  _swigc__p_SoCoordinate4,
  _swigc__p_SoCounter,
  _swigc__p_SoCube,
  _swigc__p_SoCylinder,
  _swigc__p_SoDebugError,
  _swigc__p_SoDecomposeMatrix,
  _swigc__p_SoDecomposeRotation,
  _swigc__p_SoDecomposeVec2f,
  _swigc__p_SoDecomposeVec3f,
  _swigc__p_SoDecomposeVec4f,
  _swigc__p_SoDepthBuffer,
  _swigc__p_SoDetailList,
  _swigc__p_SoDirectionalLight,
  _swigc__p_SoDirectionalLightDragger,
  _swigc__p_SoDirectionalLightManip,
  _swigc__p_SoDragPointDragger,
  _swigc__p_SoDragger,
  _swigc__p_SoDrawStyle,
  _swigc__p_SoElapsedTime,
  _swigc__p_SoEngine,
  _swigc__p_SoEngineList,
  _swigc__p_SoEngineOutput,
  _swigc__p_SoEngineOutputList,
  _swigc__p_SoEnvironment,
  _swigc__p_SoError,
  _swigc__p_SoEvent,
  _swigc__p_SoEventCallback,
  _swigc__p_SoExtSelection,
  _swigc__p_SoFaceSet,
  _swigc__p_SoField,
  _swigc__p_SoFieldContainer,
  _swigc__p_SoFieldConverter,
  _swigc__p_SoFieldList,
  _swigc__p_SoFile,
  _swigc__p_SoFont,
  _swigc__p_SoFontStyle,
  _swigc__p_SoFragmentShader,
  _swigc__p_SoFrustumCamera,
  _swigc__p_SoFullPath,
  _swigc__p_SoGLImageResizeCB,
  _swigc__p_SoGLMultiTextureCoordinateElement,
  _swigc__p_SoGLMultiTextureEnabledElement,
  _swigc__p_SoGLMultiTextureImageElement,
  _swigc__p_SoGLMultiTextureMatrixElement,
  _swigc__p_SoGLRenderAbortCB,
  _swigc__p_SoGLRenderAction,
  _swigc__p_SoGate,
  _swigc__p_SoGeoCoordinate,
  _swigc__p_SoGeoLocation,
  _swigc__p_SoGeoOrigin,
  _swigc__p_SoGeoSeparator,
  _swigc__p_SoGroup,
  _swigc__p_SoHandleBoxDragger,
  _swigc__p_SoHandleBoxManip,
  _swigc__p_SoHeightMapToNormalMap,
  _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_SoInteractionKit,
  _swigc__p_SoInterpolate,
  _swigc__p_SoInterpolateFloat,
  _swigc__p_SoInterpolateRotation,
  _swigc__p_SoInterpolateVec2f,
  _swigc__p_SoInterpolateVec3f,
  _swigc__p_SoInterpolateVec4f,
  _swigc__p_SoIntersectionCB,
  _swigc__p_SoIntersectionFilterCB,
  _swigc__p_SoIntersectionVisitationCB,
  _swigc__p_SoJackDragger,
  _swigc__p_SoJackManip,
  _swigc__p_SoKeyboardEvent,
  _swigc__p_SoLOD,
  _swigc__p_SoLabel,
  _swigc__p_SoLevelOfDetail,
  _swigc__p_SoLight,
  _swigc__p_SoLightKit,
  _swigc__p_SoLightModel,
  _swigc__p_SoLineHighlightRenderAction,
  _swigc__p_SoLineSet,
  _swigc__p_SoLinearProfile,
  _swigc__p_SoListener,
  _swigc__p_SoLocateHighlight,
  _swigc__p_SoLocation2Event,
  _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_SoMatrixTransform,
  _swigc__p_SoMemoryError,
  _swigc__p_SoMotion3Event,
  _swigc__p_SoMouseButtonEvent,
  _swigc__p_SoMultiTextureCoordinateElement,
  _swigc__p_SoMultiTextureEnabledElement,
  _swigc__p_SoMultiTextureImageElement,
  _swigc__p_SoMultiTextureMatrixElement,
  _swigc__p_SoMultipleCopy,
  _swigc__p_SoNode,
  _swigc__p_SoNodeEngine,
  _swigc__p_SoNodeKitListPart,
  _swigc__p_SoNodeKitPath,
  _swigc__p_SoNodeList,
  _swigc__p_SoNonIndexedShape,
  _swigc__p_SoNormal,
  _swigc__p_SoNormalBinding,
  _swigc__p_SoNotList,
  _swigc__p_SoNotRec,
  _swigc__p_SoNurbsCurve,
  _swigc__p_SoNurbsProfile,
  _swigc__p_SoNurbsSurface,
  _swigc__p_SoOnOff,
  _swigc__p_SoOneShot,
  _swigc__p_SoOrthographicCamera,
  _swigc__p_SoOutput,
  _swigc__p_SoPackedColor,
  _swigc__p_SoPath,
  _swigc__p_SoPathList,
  _swigc__p_SoPathSwitch,
  _swigc__p_SoPendulum,
  _swigc__p_SoPerspectiveCamera,
  _swigc__p_SoPickStyle,
  _swigc__p_SoPickedPointList,
  _swigc__p_SoPointLight,
  _swigc__p_SoPointLightDragger,
  _swigc__p_SoPointLightManip,
  _swigc__p_SoPointSet,
  _swigc__p_SoPolygonOffset,
  _swigc__p_SoProfile,
  _swigc__p_SoProfileCoordinate2,
  _swigc__p_SoProfileCoordinate3,
  _swigc__p_SoProto,
  _swigc__p_SoProtoInstance,
  _swigc__p_SoQt,
  _swigc__p_SoQtComponent,
  _swigc__p_SoQtConstrainedViewer,
  _swigc__p_SoQtCursor,
  _swigc__p_SoQtCursor__CustomCursor,
  _swigc__p_SoQtDevice,
  _swigc__p_SoQtExaminerViewer,
  _swigc__p_SoQtFlyViewer,
  _swigc__p_SoQtFullViewer,
  _swigc__p_SoQtGLWidget,
  _swigc__p_SoQtKeyboard,
  _swigc__p_SoQtMouse,
  _swigc__p_SoQtObject,
  _swigc__p_SoQtPlaneViewer,
  _swigc__p_SoQtPopupMenu,
  _swigc__p_SoQtRenderArea,
  _swigc__p_SoQtViewer,
  _swigc__p_SoQuadMesh,
  _swigc__p_SoReadError,
  _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_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_SoSelectOne,
  _swigc__p_SoSelection,
  _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_SoShapeKit,
  _swigc__p_SoShuttle,
  _swigc__p_SoSpaceballButtonEvent,
  _swigc__p_SoSphere,
  _swigc__p_SoSpotLight,
  _swigc__p_SoSpotLightDragger,
  _swigc__p_SoSpotLightManip,
  _swigc__p_SoSurroundScale,
  _swigc__p_SoSwitch,
  _swigc__p_SoTabBoxDragger,
  _swigc__p_SoTabBoxManip,
  _swigc__p_SoTabPlaneDragger,
  _swigc__p_SoTempPath,
  _swigc__p_SoText2,
  _swigc__p_SoText3,
  _swigc__p_SoTexture,
  _swigc__p_SoTexture2,
  _swigc__p_SoTexture2Convert,
  _swigc__p_SoTexture2Transform,
  _swigc__p_SoTexture3,
  _swigc__p_SoTexture3Transform,
  _swigc__p_SoTextureCombine,
  _swigc__p_SoTextureCoordinate2,
  _swigc__p_SoTextureCoordinate3,
  _swigc__p_SoTextureCoordinateBinding,
  _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_SoTextureScalePolicy,
  _swigc__p_SoTextureUnit,
  _swigc__p_SoTimeCounter,
  _swigc__p_SoTrackballDragger,
  _swigc__p_SoTrackballManip,
  _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_SoTransparencyType,
  _swigc__p_SoTriangleStripSet,
  _swigc__p_SoTriggerAny,
  _swigc__p_SoType,
  _swigc__p_SoTypeList,
  _swigc__p_SoUniformShaderParameter,
  _swigc__p_SoUnits,
  _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_SoVertexAttribute,
  _swigc__p_SoVertexAttributeBinding,
  _swigc__p_SoVertexProperty,
  _swigc__p_SoVertexShader,
  _swigc__p_SoVertexShape,
  _swigc__p_SoWWWAnchor,
  _swigc__p_SoWWWInline,
  _swigc__p_SoWrapperKit,
  _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_cc_glglue,
  _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_p_SoQtViewer__void,
  _swigc__p_f_int_p_void__void,
  _swigc__p_f_p_QWidget_p_void_p_QEvent_p_bool__void,
  _swigc__p_f_p_SoInput_p_q_const__SbString_q_const__int_p_void__p_SoProto,
  _swigc__p_f_p_q_const__SoError_p_void__void,
  _swigc__p_f_p_void__void,
  _swigc__p_f_p_void_int__void,
  _swigc__p_f_p_void_p_QEvent__int,
  _swigc__p_f_p_void_p_QEvent__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__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_SoQtComponent__void,
  _swigc__p_f_p_void_p_SoQtViewer__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_SoVRMLScript__void,
  _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__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__void,
  _swigc__p_f_p_void_p_void_p_void_p_void__void,
  _swigc__p_f_p_void_r_q_const__SbVec2f__SbVec2f,
  _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__SbString_enum_SoQt__FatalErrors_p_void__void,
  _swigc__p_f_q_const__unsigned_int__unsigned_int,
  _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_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_SoEngineOutput,
  _swigc__p_p_SoField,
  _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_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_char,
  _swigc__p_p_charp,
  _swigc__p_p_void,
  _swigc__p_read_func,
  _swigc__p_seek_func,
  _swigc__p_short,
  _swigc__p_signed_char,
  _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) {
    return NULL;
  }
#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, "SOQT_MAJOR_VERSION",SWIG_From_int(static_cast< int >(1)));
  SWIG_Python_SetConstant(d, "SOQT_MINOR_VERSION",SWIG_From_int(static_cast< int >(6)));
  SWIG_Python_SetConstant(d, "SOQT_MICRO_VERSION",SWIG_From_int(static_cast< int >(4)));
  SWIG_Python_SetConstant(d, "SOQT_VERSION",SWIG_FromCharPtr("1.6.4"));
  SWIG_Python_SetConstant(d, "GUI_TOOLKIT_VERSION",SWIG_FromCharPtr("6102"));
  SWIG_Python_SetConstant(d, "SOQT_SUN_CC_4_0_SOTYPE_INIT_BUG",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "SoQtKeyboard_KEY_PRESS",SWIG_From_int(static_cast< int >(SoQtKeyboard::KEY_PRESS)));
  SWIG_Python_SetConstant(d, "SoQtKeyboard_KEY_RELEASE",SWIG_From_int(static_cast< int >(SoQtKeyboard::KEY_RELEASE)));
  SWIG_Python_SetConstant(d, "SoQtKeyboard_ALL_EVENTS",SWIG_From_int(static_cast< int >(SoQtKeyboard::ALL_EVENTS)));
  SWIG_Python_SetConstant(d, "SoQtMouse_BUTTON_PRESS",SWIG_From_int(static_cast< int >(SoQtMouse::BUTTON_PRESS)));
  SWIG_Python_SetConstant(d, "SoQtMouse_BUTTON_RELEASE",SWIG_From_int(static_cast< int >(SoQtMouse::BUTTON_RELEASE)));
  SWIG_Python_SetConstant(d, "SoQtMouse_POINTER_MOTION",SWIG_From_int(static_cast< int >(SoQtMouse::POINTER_MOTION)));
  SWIG_Python_SetConstant(d, "SoQtMouse_BUTTON_MOTION",SWIG_From_int(static_cast< int >(SoQtMouse::BUTTON_MOTION)));
  SWIG_Python_SetConstant(d, "SoQtMouse_ALL_EVENTS",SWIG_From_int(static_cast< int >(SoQtMouse::ALL_EVENTS)));
  SWIG_Python_SetConstant(d, "SoQt_UNSPECIFIED_ERROR",SWIG_From_int(static_cast< int >(SoQt::UNSPECIFIED_ERROR)));
  SWIG_Python_SetConstant(d, "SoQt_NO_OPENGL_CANVAS",SWIG_From_int(static_cast< int >(SoQt::NO_OPENGL_CANVAS)));
  SWIG_Python_SetConstant(d, "SoQt_INTERNAL_ASSERT",SWIG_From_int(static_cast< int >(SoQt::INTERNAL_ASSERT)));
  SWIG_Python_SetConstant(d, "SoQt_DLL",SWIG_From_int(static_cast< int >(SoQt::DLL)));
  SWIG_Python_SetConstant(d, "SoQt_LIB",SWIG_From_int(static_cast< int >(SoQt::LIB)));
  SWIG_Python_SetConstant(d, "SoQt_UNKNOWN",SWIG_From_int(static_cast< int >(SoQt::UNKNOWN)));
  SWIG_Python_SetConstant(d, "SO_GL_RGB",SWIG_From_int(static_cast< int >(SO_GL_RGB)));
  SWIG_Python_SetConstant(d, "SO_GLX_RGB",SWIG_From_int(static_cast< int >(SO_GLX_RGB)));
  SWIG_Python_SetConstant(d, "SO_GL_DOUBLE",SWIG_From_int(static_cast< int >(SO_GL_DOUBLE)));
  SWIG_Python_SetConstant(d, "SO_GLX_DOUBLE",SWIG_From_int(static_cast< int >(SO_GLX_DOUBLE)));
  SWIG_Python_SetConstant(d, "SO_GL_ZBUFFER",SWIG_From_int(static_cast< int >(SO_GL_ZBUFFER)));
  SWIG_Python_SetConstant(d, "SO_GLX_ZBUFFER",SWIG_From_int(static_cast< int >(SO_GLX_ZBUFFER)));
  SWIG_Python_SetConstant(d, "SO_GL_OVERLAY",SWIG_From_int(static_cast< int >(SO_GL_OVERLAY)));
  SWIG_Python_SetConstant(d, "SO_GLX_OVERLAY",SWIG_From_int(static_cast< int >(SO_GLX_OVERLAY)));
  SWIG_Python_SetConstant(d, "SO_GL_STEREO",SWIG_From_int(static_cast< int >(SO_GL_STEREO)));
  SWIG_Python_SetConstant(d, "SO_GLX_STEREO",SWIG_From_int(static_cast< int >(SO_GLX_STEREO)));
  SWIG_Python_SetConstant(d, "SoQtViewer_BROWSER",SWIG_From_int(static_cast< int >(SoQtViewer::BROWSER)));
  SWIG_Python_SetConstant(d, "SoQtViewer_EDITOR",SWIG_From_int(static_cast< int >(SoQtViewer::EDITOR)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_AS_IS",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_AS_IS)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_HIDDEN_LINE",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_HIDDEN_LINE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_NO_TEXTURE",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_NO_TEXTURE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_LOW_COMPLEXITY",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_LOW_COMPLEXITY)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_LINE",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_LINE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_POINT",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_POINT)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_BBOX",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_BBOX)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_LOW_RES_LINE",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_LOW_RES_LINE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_LOW_RES_POINT",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_LOW_RES_POINT)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_SAME_AS_STILL",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_SAME_AS_STILL)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VIEW_WIREFRAME_OVERLAY",SWIG_From_int(static_cast< int >(SoQtViewer::VIEW_WIREFRAME_OVERLAY)));
  SWIG_Python_SetConstant(d, "SoQtViewer_STILL",SWIG_From_int(static_cast< int >(SoQtViewer::STILL)));
  SWIG_Python_SetConstant(d, "SoQtViewer_INTERACTIVE",SWIG_From_int(static_cast< int >(SoQtViewer::INTERACTIVE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_BUFFER_SINGLE",SWIG_From_int(static_cast< int >(SoQtViewer::BUFFER_SINGLE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_BUFFER_DOUBLE",SWIG_From_int(static_cast< int >(SoQtViewer::BUFFER_DOUBLE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_BUFFER_INTERACTIVE",SWIG_From_int(static_cast< int >(SoQtViewer::BUFFER_INTERACTIVE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_VARIABLE_NEAR_PLANE",SWIG_From_int(static_cast< int >(SoQtViewer::VARIABLE_NEAR_PLANE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_CONSTANT_NEAR_PLANE",SWIG_From_int(static_cast< int >(SoQtViewer::CONSTANT_NEAR_PLANE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_STEREO_NONE",SWIG_From_int(static_cast< int >(SoQtViewer::STEREO_NONE)));
  SWIG_Python_SetConstant(d, "SoQtViewer_STEREO_ANAGLYPH",SWIG_From_int(static_cast< int >(SoQtViewer::STEREO_ANAGLYPH)));
  SWIG_Python_SetConstant(d, "SoQtViewer_STEREO_QUADBUFFER",SWIG_From_int(static_cast< int >(SoQtViewer::STEREO_QUADBUFFER)));
  SWIG_Python_SetConstant(d, "SoQtViewer_STEREO_INTERLEAVED_ROWS",SWIG_From_int(static_cast< int >(SoQtViewer::STEREO_INTERLEAVED_ROWS)));
  SWIG_Python_SetConstant(d, "SoQtViewer_STEREO_INTERLEAVED_COLUMNS",SWIG_From_int(static_cast< int >(SoQtViewer::STEREO_INTERLEAVED_COLUMNS)));
  SWIG_Python_SetConstant(d, "SoQtFullViewer_BUILD_NONE",SWIG_From_int(static_cast< int >(SoQtFullViewer::BUILD_NONE)));
  SWIG_Python_SetConstant(d, "SoQtFullViewer_BUILD_DECORATION",SWIG_From_int(static_cast< int >(SoQtFullViewer::BUILD_DECORATION)));
  SWIG_Python_SetConstant(d, "SoQtFullViewer_BUILD_POPUP",SWIG_From_int(static_cast< int >(SoQtFullViewer::BUILD_POPUP)));
  SWIG_Python_SetConstant(d, "SoQtFullViewer_BUILD_ALL",SWIG_From_int(static_cast< int >(SoQtFullViewer::BUILD_ALL)));
  SWIG_Python_SetConstant(d, "SoQtCursor_CUSTOM_BITMAP",SWIG_From_int(static_cast< int >(SoQtCursor::CUSTOM_BITMAP)));
  SWIG_Python_SetConstant(d, "SoQtCursor_DEFAULT",SWIG_From_int(static_cast< int >(SoQtCursor::DEFAULT)));
  SWIG_Python_SetConstant(d, "SoQtCursor_BUSY",SWIG_From_int(static_cast< int >(SoQtCursor::BUSY)));
  SWIG_Python_SetConstant(d, "SoQtCursor_CROSSHAIR",SWIG_From_int(static_cast< int >(SoQtCursor::CROSSHAIR)));
  SWIG_Python_SetConstant(d, "SoQtCursor_UPARROW",SWIG_From_int(static_cast< int >(SoQtCursor::UPARROW)));
  return 0;
}

